Descubrí por Twitter el concurso que organizaba Logiker, un aficionado al Commodore 64. Se trataba del Vintage Computing Christmas Challenge 2021 (VC³ 2021). Lo que me llamó la atención es que estaba abierto a cualquier plataforma, y también a cualquier lenguaje.
Nunca dominé el C64, así que barajé Sinclair BASIC para ZX Spectrum, Javascript/ECMAScript para un navegador web, PowerBasic para DOS, y terminé centrándome en justamente eso: PC/DOS, la plataforma que probablemente más conozco. Este era el ejemplo que Logiker proponía:
100 print " * 110 print " *** 120 print " ***** 130 print " ******* 140 print " *** 150 print " ******* 160 print " *********** 170 print " *************** 180 print " ***** 190 print " *********** 200 print " ***************** 210 print " *********************** 220 print " *** 230 print " ***
El resultado debía ser el mismo, dibujar exactamente ese árbol en pantalla de modo texto usando el mismo carácter, y centrándolo en pantalla. Lo primero que se me ocurrió fue usar GW-BASIC y sus modos de «shortcut» que permitían ahorrar la escritura de varios caracteres. Así «?» equivalía a «PRINT» o «‘» a «REM». El algoritmo era sencillo, montar un array con la longitud de asteriscos por línea (1, 3, 5, …) y entonces irlo recorriendo para poner tantos espacios en blanco como 40 menos la longitud de las estrellas, y luego repetir el símbolo de asterisco tantas veces como fuera posible.
Comencé a escribirlo y me di cuenta que ese código «optimizado» iba a ser más largo que el original, es difícil optimizar algo que ya de inicio son 510 bytes nada más. Así que me centré en condensar el código en la medida de lo posible:
1 ?" *":?" ***":?" *****":?" *******":?" ***":?" *******":?" ***********":?" ***************":?" *****" 2 ?" ***********":?" *****************":?" ***********************":?" ***":?" ***"
Ya se puede ver que no es nada elaborado, una condensación de código que ahora llamamos minificación al más puro estilo JSMin. El resultado fueron 392 bytes, un buen ahorro, que podría haber sido más si GW-BASIC hubiera permitido líneas de más de 255 caracteres de longitud.
Cómo siempre os dejo aquí el código fuente incluyendo GW-BASIC.EXE para MS-DOS/PC-DOS de forma que podáis ejecutarlo fácilmente (60 KB. en formato ZIP).
Actualizado a jueves 23 de diciembre de 2021. 20:33:
Se acaba de publicar el vídeo acerca del concurso. No os lo perdáis porque todas las participaciones son alucinantes.
Te ha quedado muy simpático, una iniciativa muy curiosa ésta de representar un símbolo entrañable a través de un lenguaje tan duro y frío; desde una mirada profunda refleja la capacidad humana de transformar la realidad para mejor, un mensaje muy propio de estas fiestas, felicidades.
Muchas gracias jostma. Son de esas iniciativas que me parecen bonitas y originales. Por falta de tiempo me es imposible participar en todas, pero sí que es verdad que cuando encuentro algo que me parece distinto intento aplicarme.
y yo que ya estaba pensando en fors y gotos… Te ha quedado muy eficiente. Lo que haces por ahorrarte teclear cuatro letras, Guti 😀
Así es como lo empecé a plantear Droid Drika, con for. No sé si recordaras que los BASIC tienen desde siempre la función SPACE$/SPACE que generaba tantos espacios como le pasases como argumento y STRING$/STRING que generaba tantos caracteres como le indicases. Pues un poco esa era la idea, aunque al probarlo ya me di cuenta que no se ahorraría nada. El mejor caso es la línea con 17 asteriscos, una cadena cuyo original es así:
La podrías generar como:
STRING$(17,»*»)
Es decir, en vez de 17 necesitas 16, pero para el resto de líneas te ocuparía mucho más que ponerlo normal. Fue entonces cuando decidí que podría crear un array con la cantidad de estrellas por línea y entonces usar ese array para dinámicamente calcular los espacios y repetir los asteriscos. Suena fácil, pero la cosa se complicaba. Hay que recordar que inicializar un array en aquellos dialectos de BASIC pasaba por los DATA, algo así:
10 DATA 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
20 DIM A(9)
30 FOR I = 0 TO 9
40 READ A(I)
50 NEXT
Y claro, sólo generar el array para luego recorrerlo ya era más largo que hacerlo a pelo. Hay más opciones, pero al final las acabé descartando, aunque una de ellas era simplemente pasar del array y usar una cadena con las longitudes:
LET a$=»1,2,3,4″…
De nuevo implicaría ir recorriendo la cadena. A veces lo simple es lo mejor.
A todo esto, que hay innumerables escaneados del manual de GW-Basic disponibles, pero este navegable en formato HTML, aunque antiguo, me gusta mucho: https://hwiegman.home.xs4all.nl/gw-man/
Que chulo está ese manual… Me recuerda al Delphi Basic: http://www.delphibasics.co.uk/index.html Aunque en este caso mucho mejor, puesto que además de navegable, el de Delphi es descargable.
Yo arrais no quiero ver ni en pintura, ya los sufrí bastante cuando estudié. Para hacer lo que tú has hecho necesitas un conocimiento muy profundo del lenguaje, porque por lo general todos tiraríamos a los convencionalismos.
Pasé muchísimos años con el PC anclado en GW-Basic Droid Drika. Los PC apenas estaban implantados, y obtener software que no fueran juegos era harto complicado. Vamos, que llegué a dominar el BASIC a base de leerme y releerme el manual una y otra vez. Luego vendría por fortuna Turbo BASIC y sería un mundo nuevo.