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
- neodevelop's blog
- Inicie sesión o regístrese para enviar comentarios
Comentarios
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"
"| |" +
" - " +
"| |" +
" - ";
assert convertToLCD(8) == number;
1ra ( pregunta troll de hecho )
No debería de ser
?
Porque la variable
number
no existe:) :)
2da ( ya más seria )
No debería de ser:
"| |\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
? o42
?" | | |\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...
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
// ********* 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
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) );
}
}
...
_ _ _ _ _ _ _ _
| _| _||_||_ |_ ||_||_|| |
||_ _| | _||_| ||_| _||_|
Mismo principio, diferente
Mismo principio, diferente lenguaje ( Go )
https://gist.github.com/2129414
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.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.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();
}
}
}
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)
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';
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.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.
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*
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