Creo que las preguntas de arte ASCII sobre PPCG son divertidas de hacer, pero personalmente creo que puede ser bastante difícil, especialmente cuando la pregunta está etiquetada como código-golf .

Me pregunto si alguien aquí podría tener algunos consejos que sean útiles para producir arte ASCII.

Simplemente organizar los caracteres es fácil, pero con algoritmos (cortos), las cosas se volverán más complicadas.

Estoy hablando del arte ASCII como:

• Texto al arte ASCII (caracteres)
• Imágenes (logotipos o íconos)

Solo estoy buscando consejos generales, pero se permiten idiomas específicos, ya que la mayoría de ellos se pueden traducir de todos modos.

Algoritmos de compresión

Puede aplicar compresión LZMA a la cadena.
Muchos idiomas lo admiten.

Codificación de longitud de ejecución

Puede usar instrucciones de procesamiento como [char][number](por ejemplo b12).
Este algoritmo de compresión se usa aquí: /codegolf//a/20589/10920

Lectura adicional: http://en.wikipedia.org/wiki/Run-length_encoding

Embalaje entero

Puede usar matrices de enteros para almacenar formas pequeñas como:

// This is an invader!
// (SE line height makes it looks awful)
// ~158 characters

    ##          ##    
      ##      ##      
    ##############    
  ####  ######  ####  
######################
##  ##############  ##
##  ##          ##  ##
      ####  ####       

Cada espacio se traducirá a a 0.
Cada sostenido se traducirá en a 1.

// ~58 characters
// Saved ~100 bytes!
[
  196656,  49344,   262128,  999228,
  4194303, 3407859, 3342387, 62400
]

Cada bit se lee utilizando el operador bit a bit &.

El algoritmo anterior podría mejorarse utilizando una base entera más grande:

// ~44 characters
// Integers are in base 36.
// Use `_` as a separator (or a line break).
"47qo_122o_5m9c_lf0c_2hwcf_211ir_1zn03_1c5c"

Busque simetría

A veces, el arte ASCII requerido es simétrico en algún momento. Por ejemplo, Argyle ASCII Art requiere una salida similar a esta:

    /\        /\
   /  \  /\  /  \
/\/    \/  \/    \/\
\/\    /\  /\    /\/
   \  /  \/  \  /
    \/        \/

Uno podría imprimir esto normalmente, pero dependiendo del idioma, el código requerido puede acortarse generando solo la mitad superior del resultado, invirtiéndolo e intercambiando /y \.

Intenta transponer

En ASCII Art Archery Arrows, el resultado para imprimir es este, escalado a un dado n:

     /\
    /  \
   /    \
  /      \
  \      /
   \____/
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
   /|  |\
  / |  | \
 /  |  |  \
/   |  |   \
/   |  |   \
/   |__|   \
/  /    \  \
/ /      \ \
//        \\
/          \

Si echamos un vistazo a la flecha, podemos ver que hay 8 tipos de líneas:

/ \
\ /
\_/
| |
/ | | \
/ |_| \
/ / \ \
/ \

Probemos lo mismo para su transposición.

                         ///////
                        /     / 
   /\                  /     /  
  /  \                /     /   
 /   _||||||||||||||||||||||    
/    _                     _    
\    _                     _    
 \   _||||||||||||||||||||||    
  \  /                \     \   
   \/                  \     \  
                        \     \ 
                         \\\\\\\

Aquí, hay 10 tipos de líneas.

/
/ /
/ \ / /
/ _|
/ _ _
\ _ _
\ _|
\ / \ \
\ \
\

Pero aquí está el truco: los 5 inferiores son idénticos a los 5 superiores, excepto por el intercambio /y \. Según la regla anterior, primero puede generar los primeros 5, copiar, hacer el intercambio y finalmente transponer para obtener la flecha. Esto puede ahorrar mucho código.

Controlar personajes, secuencias de escape y códigos de consola

A menos que la pregunta los prohíba, el consenso actual sobre Meta es que los desafíos de arte ASCII no requieren un flujo de bytes específico, sino un resultado que se ve correcto.

Esto significa que podemos usar caracteres de control ASCII , secuencias de escape ANSI y códigos de consola Linux en nuestras respuestas, suponiendo un terminal compatible.

A menos que se especifique lo contrario, el resto de esta respuesta explicará el comportamiento de los terminales de Linux, que es lo que tengo disponible para probar en este momento.

Caracteres de control ASCII

El soporte / interpretación varía de terminal a terminal y de personaje a personaje. El más portátil debería ser el salto de línea ( \n,\x0a ), que mueve al personaje al comienzo de la siguiente línea.

Otros caracteres útiles incluyen:

• La pestaña vertical ( \v, \x0b) mueve el cursor una posición hacia la derecha, luego una posición hacia abajo.

  $ echo -e 'a\vb'
  a
   b
  

• El retorno de carro ( \r, \x0d) mueve el cursor al comienzo de la línea actual . Cualquier carácter imprimible posterior sobrescribirá el primer carácter de la línea actual.

  $ echo -e 'ab\rc'
  cb
  

• El retroceso ( \b, \x08) mueve el cursor una posición hacia la izquierda. Cualquier carácter imprimible posterior sobrescribirá el carácter antes del retroceso.

  $ echo -e 'ab\bc'
  ac
  

• El escape ( \e, \x1b) no hace nada por sí solo, sino que forma parte de las secuencias de escape ANSI (opcionalmente) y los códigos de la consola de Linux.

Muchos idiomas permiten caracteres de control reales en el código fuente.

Secuencias de escape ANSI

(está por venir)

Códigos de consola de Linux

Si bien hay muchos más, los códigos de consola más útiles para el arte ASCII son probablemente estos:

• La secuencia \ecse restablecer el terminal. Esto borra la pantalla, mueve el cursor a la esquina superior izquierda y establece el color anterior y de fondo, la velocidad de parpadeo del cursor, etc. a sus valores predeterminados.

• La secuencia \eMprovoca un salto de línea inverso , es decir, el cursor se moverá una posición hacia arriba.

  $ echo -e '\na\eMb\n'
   b
  a
  

• La secuencia \eHestablece la tabulación en la columna actual.

  $ echo -e '   \eHa\n\tb'
     a
     b
  

Busca patrones

Este puede ser un poco obvio, pero ... busque patrones, similitudes y repeticiones en la salida. Por ejemplo, cuando vi el número Transformar en una tarea de patrón de visualización de 7 segmentos , comencé a pensar en cómo se podía jugar golf y comencé a buscar similitudes. Debido a la forma en que los segmentos horizontales van entre los verticales en la matriz de caracteres, probablemente sería más fácil tratar con tres segmentos a la vez, agrupados como tales (agregando dos segmentos "siempre vacíos" para el primero, el superior) :

Por lo tanto, se podía hacer algo como lc + " "*N + rc + "\n"N-1 veces y luego lc + bc*N + rcuna vez, por cada tres segmentos ( lc, bc, rcsiendo los caracteres izquierda arriba, abajo, a la derecha y del segmento, es decir, uno de |, _o  ).

Usar conversión base

Esta respuesta fue a una pregunta que quería arte ASCII que consistía en los personajes + |-y las nuevas líneas. Como solo hay 5 caracteres posibles, estos pueden tratarse como un número base 5 y convertirse en bytes, con 3.45 caracteres por byte.

Explotar regularidades

A menudo, los datos tendrán algunas regularidades, incluso si esas regularidades no son lo suficientemente fuertes como para emplear herramientas específicas como la duplicación. Por ejemplo, en la pregunta anterior, el resultado deseado tenía líneas nuevas espaciadas aproximadamente de manera uniforme a lo largo de la prueba, ya que el texto era aproximadamente rectangular. Exploté esto para acortar mi código, usando la función dividir en n piezas de Pyth, luego uniéndome en nuevas líneas.

Conozca sus herramientas y elija la correcta para el trabajo.

Las herramientas de procesamiento de texto más potentes y eficientes que conozco son:

Motores Regex: ///Retina, Perl, en orden de compensación de potencia / concisión.

Úselo si lo que quiere hacer puede describirse de manera concisa en sustituciones de expresiones regulares, como esta respuesta

Herramientas oscuras de procesamiento de texto: gema, etc. (estoy seguro de que hay otras, pero son demasiado oscuras)

Úselo si tienen una función que es exactamente lo que necesita, que nada más tiene. Como en esta pregunta , con la coincidencia recursiva de gema.

Lenguajes de golf de código general: CJam, Pyth, etc.

Úselo si está explotando alguna sutileza lo suficientemente compleja como para que ninguna otra herramienta haga el trabajo o simplemente haga el trabajo más corto.

Prueba muchos enfoques

Esto se aplica en todas las preguntas de código de golf, pero especialmente aquí. No vas a saber si una regularidad es explotable hasta que la pruebes. Posiblemente en varios idiomas.