style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

VideoPodcast de ViveCodigo 00x15 : Coding Dojo

VideoPodcast de ViveCodigo 00x15 : Coding Dojo

A través del sitio de ViveCodigo.org, se ha publicado su última edición en donde se realizó un Coding Dojo, en el video, se muestra a los asistentes resolviendo una Kata de nombre "Numbers to LCD", para más detalle al respecto te recomendamos visitar el blog post.

http://vivecodigo.org/2012/03/15/podcast-15-de-la-temporada-0/

Saludos

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

ultimo...?

"último" como en "el más reciente", o "último" como en "ya no habrá más"?

Dos preguntas sobre el

Dos preguntas sobre el inicio:

"Esto es lo primero que se debe realizar"

String numberLCD =  " - " +
                    "| |" +
                    " - " +
                    "| |" +
                    " - ";
assert convertToLCD(8) == number;

1ra ( pregunta troll de hecho )
No debería de ser

assert convertToLCD( 8 ) == numberLCD;

?

Porque la variable number no existe

:) :)

2da ( ya más seria )

No debería de ser:

String numberLCD =  " - \n" +
                    "| |\n" +
                    " - \n" +
                    "| |\n" +
                    " - ";

Es decir, con retornos de carro??

Tercera pregunta ( jejej había dicho 2 verdad? )

El método debe de funcionar para más de un número, por ejemplo 10? o 42?

assert convertLCD( 10 ) == "     - \n"+
                           "  | | |\n"+
                           "  | |_|";

Saludos.

Uff ya... me estaba haciendo

Uff ya... me estaba haciendo bolas con los indices...

Yey!! TDD realmente funciona ... ahora a ver las soluciones ...

¬¬

mmmhhh de verdad llegaron a esas soluciones con TDD??? ¿Porque solamente Alcides con Racket tiene un switch ( bueno el equivalente a un switch ) si era lo máaaaas inmediato? Lo que TDD dice es "Hacer lo mínimo posible, para que la prueba pase" Mmhh a mi se me hace que pensaron más allá de lo que la prueba decía ( o quizá no entendí bien ) En fin ... :P

Ahí va mi código ( si... en C# no me cuelguen porfavor )

https://gist.github.com/2065733

Pues claaaro, usando un switch y luego cuando es más de 1 dígito, pegandolos a la fuerza :P

Saludos

LOL

@chochosmx
Si es del mas reciente, pero también hay que notar que ya mero acaba la temporada 0, en Abril de hecho, entonces si seria uno de los últimos...

^_^

@oscaryz
Si perdón se nos fue en la redacción, lo corregimos...
Efectivamente es con saltos de linea, esa inferencia es de cada quien, pues seria confuso ponerlo como " - \n| |\n......"
En una siguiente aproximación, una vez que ya tienes del 0 al 9, tendrías que agregar esa funcionalidad para que acepte mas de dos dígitos, de hecho, el ejercicio no se debe pensar en miras a mas de dos dígitos, si no un avance gradual. Esto ultimo nos paso en cierta medida dentro del Dojo pues 'no lo hicimos lo mas simple posible', pero precisamente para eso son los dojos.
Saluditos y gracias por los comentarios...

Imagen de Sr. Negativo

De C# a Java

@OscarRyz

Me tome el atrevimiento de copiar tu código para usar el "convertidor" de C# a Java y aqui el resultado:
http://codeporting.com/apps/csharp-2-java

package CodingKata;

// ********* THIS FILE IS AUTO PORTED FORM C# USING CODEPORTING.COM *********

import com.codeporting.csharp2java.System.msString;

 
class LCDConverter
{

    public String convertToLCD (int number)
    {
        if ( number < 0 ) throw new IllegalArgumentException("Parameter name: " + "Only > 0 please");

        String result = "";
        int i      = 0;
        for ( char c : (Iterable<Character>) Integer.toString(number) )
        {
            String lcdDigit = "";
            int n = (int) char.GetNumericValue(c);
            switch ( n )
            {
                //>>>>>>>> #region  switch assign to lcdDigit
                case 0: lcdDigit =
                     " _ \n"+
                     "| |\n"+
                     "|_|\n";
                    break;
                case 1: lcdDigit =  
                    "   \n"+
                    "  |\n"+
                    "  |\n";
                    break;
                case 2: lcdDigit =  
                    " _ \n"+
                    " _|\n"+
                    "|_ \n";
                    break;
                case 3: lcdDigit =  
                    " _ \n"+
                    " _|\n"+
                    " _|\n";
                    break;
                case 4: lcdDigit =  
                    "   \n"+
                    "|_|\n"+
                    "  |\n";
                    break;
                case 5: lcdDigit =  
                    " _ \n"+
                    "|_ \n"+
                    " _|\n";
                    break;
                case 6: lcdDigit =
                    " _ \n"+
                    "|_ \n"+
                    "|_|\n";
                    break;
                case 7: lcdDigit =
                    " _ \n"+
                    "  |\n"+
                    "  |\n";
                    break;
               
                case 8: lcdDigit =  
                    " _ \n"+
                    "|_|\n"+
                    "|_|\n";
                    break;
                case 9: lcdDigit =
                    " _ \n"+
                    "|_|\n"+
                    " _|\n";
                    break;
                //<<<<<<<< #endregion
            }
            result = i == 0 ? lcdDigit : msString.insert(msString.insert(msString.insert(result,  9 * i+2 , lcdDigit.substring ((8), (8) + (3))),  6 * i+1 , lcdDigit.substring ((4), (4) + (3))),  3 * i   , lcdDigit.substring ((0), (0) + (3))) ;                                
            i++;
        }
        return result;
    }

    public static void main()
    {
        System.out.printf ( new LCDConverter().convertToLCD(1234567890) );
        System.out.printf ( new LCDConverter().convertToLCD(-1) );
    }
}

o_0

Mira.... muy bonito... muuy

Mira.... muy bonito... muuy bonito.. y casi compila.

Ahi van las modificaciones necesarias ( si es Java, debe de empezar con la llave en la misma línea )

Saludos

package codingKata;
 
class LCDConverter {
    public String convertToLCD (int number) {
        if ( number < 0 ) {
            throw new IllegalArgumentException("Only > 0 please");
        }
        String result = "";
        int i         = 0;
        for ( char c : Integer.toString(number).toCharArray() ) {
            String lcdDigit = "";
            int n = Character.getNumericValue(c);
            switch ( n ) {
                //>>>>>>>> #region  switch assign to lcdDigit
                case 0: lcdDigit =
                     " _ \n"+
                     "| |\n"+
                     "|_|\n";
                    break;
                case 1: lcdDigit =  
                    "   \n"+
                    "  |\n"+
                    "  |\n";
                    break;
                case 2: lcdDigit =  
                    " _ \n"+
                    " _|\n"+
                    "|_ \n";
                    break;
                case 3: lcdDigit =  
                    " _ \n"+
                    " _|\n"+
                    " _|\n";
                    break;
                case 4: lcdDigit =  
                    "   \n"+
                    "|_|\n"+
                    "  |\n";
                    break;
                case 5: lcdDigit =  
                    " _ \n"+
                    "|_ \n"+
                    " _|\n";
                    break;
                case 6: lcdDigit =
                    " _ \n"+
                    "|_ \n"+
                    "|_|\n";
                    break;
                case 7: lcdDigit =
                    " _ \n"+
                    "  |\n"+
                    "  |\n";
                    break;
               
                case 8: lcdDigit =  
                    " _ \n"+
                    "|_|\n"+
                    "|_|\n";
                    break;
                case 9: lcdDigit =
                    " _ \n"+
                    "|_|\n"+
                    " _|\n";
                    break;
                //<<<<<<<< #endregion
            }
           result = i == 0 ? lcdDigit : new StringBuilder( result )
                        .insert( 9 * i+2 , lcdDigit.substring (8,11))
                        .insert( 6 * i+1 , lcdDigit.substring (4,7))
                        .insert( 3 * i   , lcdDigit.substring (0,3))
                        .toString();  
           
            i++;
        }
        return result;
    }
    public static void main( String ... args ) {
        System.out.printf ( new LCDConverter().convertToLCD(1234567890) );
        System.out.printf ( new LCDConverter().convertToLCD(-1) );
    }
}

...

localhost:java oscarryz$ java codingKata.LCDConverter
    _  _     _  _  _  _  _  _
  | _| _||_||_ |_   ||_||_|| |
  ||_  _|  | _||_|  ||_| _||_|

Mismo principio, diferente

Mismo principio, diferente lenguaje ( Go )

https://gist.github.com/2129414

Imagen de rodrigo salado anaya

CodingDojo LCD C#

Yo me lo eche ese mismito día de manera remota en C#, upssss, pero bueno en realidad el lenguaje es lo de menos.
Y de manera muy subterránea intercambie un par de líneas de código y me pasaron unos muy buenos tips, ojala el Sr. Alfredo Chavez (@alfredochv) se anime a compartir las recomendaciones que me dio : )

En Groovy a de quedar super fregon...

Saludos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DigitosCool
{
    class Digito
    {
        /// <summary>
        /// Diccionario que define los diferentes símbolos para pintar los números.
        /// </summary>
        private Dictionary<int, string> leds = new Dictionary<int, string>()
        {
            {0, "   "}, {1, " _ "}, {2, "| |"}, {3, "|_|"}, {4, " | "}, {5, " _|"}, {6, "|_ "}, {7, "  |"}, {8, "|  "}, {9, " \\|"}
        };

        private string fila_1 = null;
        private string fila_2 = null;
        private string fila_3 = null;

        /// <summary>
        /// Convierte un entero a modo display.
        /// </summary>
        /// <param name="numeroDeEntrada">Número ha convertir.</param>
        private void ConvierteDigito(char numeroDeEntrada)
        {
            switch (numeroDeEntrada)
            {
                case '0': AsignaValoresALasFilas(1, 2, 3); break;
                case '1': AsignaValoresALasFilas(0, 4, 4); break;
                case '2': AsignaValoresALasFilas(1, 5, 6); break;
                case '3': AsignaValoresALasFilas(1, 5, 5); break;
                case '4': AsignaValoresALasFilas(0, 3, 7); break;
                case '5': AsignaValoresALasFilas(1, 6, 5); break;
                case '6': AsignaValoresALasFilas(1, 6, 3); break;
                case '7': AsignaValoresALasFilas(1, 7, 7); break;
                case '8': AsignaValoresALasFilas(1, 3, 3); break;
                case '9': AsignaValoresALasFilas(1, 3, 5); break;
                case 'V': AsignaValoresALasFilas(0, 2, 9); break;
                case 'C': AsignaValoresALasFilas(1, 8, 6); break;
                case 'D': AsignaValoresALasFilas(0, 5, 3); break;
            }
        }

        /// <summary>
        /// Asigna los símbolos necesarios a cada fila que representa un digito.
        /// </summary>
        /// <param name="_1">Símbolo para fila 1.</param>
        /// <param name="_2">Símbolo para fila 2.</param>
        /// <param name="_3">Símbolo para fila 3.</param>
        private void AsignaValoresALasFilas(int _1, int _2, int _3)
        {
            fila_1 = leds[_1]; fila_2 = leds[_2]; fila_3 = leds[_3];
        }

        /// <summary>
        /// Convierte una lista de caracteres numéricos a símbolos de display.
        /// </summary>
        /// <param name="numerosDeEntrada">Lista de caracteres ha convertir.</param>
        /// <returns>Número[s] estilo display.</returns>
        public string ConvirteDigitos(string numerosDeEntrada)
        {
            string filaCompleta_1 = null, filaCompleta_2 = null, filaCompleta_3 = null;

            foreach (var caracterNuemrico in numerosDeEntrada)
            {
                var digito = new Digito();
                digito.ConvierteDigito(caracterNuemrico);
                filaCompleta_1 += digito.fila_1 + ' ';
                filaCompleta_2 += digito.fila_2 + ' ';
                filaCompleta_3 += digito.fila_3 + ' ';
            }
            return filaCompleta_1 + '\n' + filaCompleta_2 + '\n' + filaCompleta_3;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DigitosCool
{
    class Program
    {
        static void Main(string[] args)
        {
            var digitoCool = new Digito();
            Console.WriteLine(digitoCool.ConvirteDigitos("V1V3 C0D160"));
            Console.Read();
        }
    }
}

Imagen de rodrigo salado anaya

CodingDojo(LCD) Groovy

Pues no resistí las ganas de hacerlo en Groovy y este es el resultado, y claro con sus pruebas y usando TDD :P (porque si no luego de cabrean y no voy a decir quien si no Alfred se va a enojar jajaja)

led = [vacio:'   ',  medio:' _ ', lados: '| |', lleno:'|_|', sinIzq: ' _|', sinDer: '|_ ', alaizq: '|  ', alaDer: '  |']
lcd = [
        0:[led.medio, led.lados, led.lleno],
        1:[led.vacio, led.alaDer, led.alaDer],
        2:[led.medio, led.sinIzq, led.sinDer],
        3:[led.medio, led.sinIzq, led.sinIzq],
        4:[led.vacio, led.lleno, led.alaDer],
        5:[led.medio, led.sinDer, led.sinIzq],
        6:[led.medio, led.sinDer, led.lleno],
        7:[led.medio, led.alaDer, led.alaDer],
        8:[led.medio, led.lleno, led.lleno],
        9:[led.medio, led.lleno, led.sinIzq],
      ]
     
def numeroLCD(digitos){
    filas = []
    digitoLCD = '';
    digitos.toString().each{
        digito = it as int
        filas << lcd[digito]        
    }
   
    (0..2).each{ indice ->
        filas.each{ fila ->
            digitoLCD += fila[indice]
        }
        digitoLCD += '\n'
    }
    digitoLCD
}

assert numeroLCD(102) ==      '    _  _ ' +
                       '\n' + '  || | _|' +
                       '\n' + '  ||_||_ '+
                       '\n';    
                       
assert numeroLCD(10) ==       '    _ ' +
                       '\n' + '  || |' +
                       '\n' + '  ||_|' +
                       '\n';                      

assert numeroLCD(0) ==        ' _ ' +
                       '\n' + '| |' +
                       '\n' + '|_|' +
                       '\n';          
                       
assert numeroLCD(1) ==    '   ' +
                       '\n' + '  |' +
                       '\n' + '  |' +
                       '\n';          
assert numeroLCD(2) ==        ' _ ' +
                       '\n' + ' _|' +
                       '\n' + '|_ ' +
                       '\n';          
                       
assert numeroLCD(3) ==        ' _ ' +
                       '\n' + ' _|' +
                       '\n' + ' _|' +
                       '\n';          
                       
assert numeroLCD(4) ==        '   ' +
                       '\n' + '|_|' +
                       '\n' + '  |' +
                       '\n';          
                       
assert numeroLCD(5) ==        ' _ ' +
                       '\n' + '|_ ' +
                       '\n' + ' _|' +
                       '\n';          
                       
assert numeroLCD(6) ==        ' _ ' +
                       '\n' + '|_ ' +
                       '\n' + '|_|' +
                       '\n';          
                       
assert numeroLCD(7) ==        ' _ ' +
                       '\n' + '  |' +
                       '\n' + '  |' +
                       '\n';          
                       
assert numeroLCD(8) ==        ' _ ' +
                       '\n' + '|_|' +
                       '\n' + '|_|' +
                       '\n';          
                       
assert numeroLCD(9) ==        ' _ ' +
                       '\n' + '|_|' +
                       '\n' + ' _|' +
                       '\n';          

Imagen de ezamudio

En Ceylon

no cabe duda que hay un montón de maneras distintas de resolverlo, y no solamente por el lenguaje que se use, sino sobre todo por la manera de atacar el problema. Aquí mi solución usando Ceylon. La idea central es que para un dígito se necesitan 7 partes, y se representa con una clase que sabe qué partes tiene cada uno; el despliegue consiste en convertir cada dígito del número a desplegar en un Digito y luego armar una cadena con las partes correspondientes de cada dígito, renglón por renglón.

Imagen de yngwie74

TDD y switch

Si, al principio TDD te sugiere usar un SWITCH... o mejor dicho, no te sugiere nada pues solo tienes uno o dos dígitos y, como bien mencionas, lo más inmediato es una secuencia de IF's o un SWITCH. Sin embargo, el SWITCH pronto se convierte en un "smell" conforme avanza la kata y es evidente la necesidad de refactorizar. De hecho, me sorprende que la solución en C# de Rodrigo haya utilizado un enfoque "híbrido": un diccionario *Y* un switch.

Al utilizar TDD, te aseguras de solo escribir el código necesario para cumplir con los requerimientos actuales. Pero TDD también es un habilitador de la limpieza de código. La teoría es que después de conseguir que tu código pase prueba actual, debes realizar la limpieza que juzgues necesaria sobre el mismo: RED-GREEN-REFACTOR!. Probablemente el diccionario + switch sea debido a un refactoring que faltó al final.

No puedo hablar a nombre de Alcides, Edgar, Teo, J.J. o nadie más, pero a mi me parece que si bien todos coincidimos en la importancia de las pruebas unitarias en el desarrollo de software, no todos coincidimos en que la meta de este dojo era el realizar la kata usando TDD de forma estricta, o por lo menos, no todos concebimos el proceso de TDD de la misma manera.

Imagen de yngwie74

C# refactored

Ok, ok, el resultado del intercambio de mails del que habla Rodrigo está aquí: https://gist.github.com/2025475 y las pruebas aquí: https://gist.github.com/2025462

Estaba a punto de hacer un comentario sobre la versión en groovy cuando me dí cuenta de que no era un problema con el código, sino con mi comprensión del lenguaje! :P

Quedó muy chido y sin necesidad de objetos... *sigh*

Imagen de iamcoder

TDD

Hola

Yo creo que el tema de TDD es muy extenso y tenebroso, hay quienes son muy puristas, hay quienes somos mas liberales en ese aspecto.

Respecto a la sesion de vivecodigo desgraciadamente no se ve como evolucionaron las pruebas unitarias con el codigo, en mi caso creo explique vagamente como llegue a la conclusion del armado de bloques en los digitos,

y como se comento fuera de camara, TDD no tiene fin, como menciona yngwie74 desde su punto de vista falto refactorización, y cuando lo hagan seguro podran hacer algo mas...

yo solo les quiero dejar una cita de no se quien "In software doesn't exit "done" only "enought by now" "

les dejo la liga de mi codigo en la sesion , actualmente el codigo tiene la implementacion de la fase de la kata la cual es que regrese la representacion en led de cualquier numero

https://github.com/elopezanaya/Katas

saludos

i code for money and sometimes for pride

creo que te voy a robar tu

creo que te voy a robar tu frase mr. iamcoder

"In software doesn't exist 'done' only 'enough by now' "

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">