Acho que as questões artísticas ASCII sobre PPCG são divertidas, mas pessoalmente acho que pode ser bem difícil, especialmente quando a pergunta é marcada como código-golfe .

Gostaria de saber se alguém aqui pode ter algumas dicas que serão úteis para a produção de arte ASCII.

Simplesmente organizar caracteres é fácil, mas com algoritmos (curtos), as coisas se tornam mais complicadas.

Eu estou falando sobre arte ASCII como:

• Texto para arte ASCII (caracteres)
• Imagens (logotipos ou ícones)

Só estou procurando dicas gerais, mas é permitido um idioma específico, pois a maioria deles pode ser traduzida de qualquer maneira.

Algoritmos de compressão

Você pode aplicar a compactação LZMA à string.
Muitos idiomas suportam.

Codificação de duração da execução

Você pode usar instruções de processamento como [char][number](por exemplo b12).
Esse algoritmo de compactação é usado aqui: /codegolf//a/20589/10920

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

Embalagem inteira

Você pode usar matrizes de números inteiros para armazenar formas pequenas, como:

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

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

Cada espaço será traduzido para a 0.
Cada afiado será traduzido para a 1.

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

Cada bit é então lido usando o operador bit a bit &.

O algoritmo acima pode ser aprimorado usando uma base inteira maior:

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

Procure simetria

Às vezes, a arte ASCII necessária é simétrica em algum momento. Por exemplo, Argyle ASCII Art requer uma saída semelhante a esta:

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

Pode-se simplesmente imprimir isso normalmente, mas, dependendo do idioma, o código necessário pode ser reduzido, gerando apenas a metade superior do resultado, revertendo-o e trocando /e \.

Tente transpor

Em ASCII Art Archery Arrows, o resultado a ser impresso é este, dimensionado para um dado n:

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

Se dermos uma olhada na seta, podemos ver que existem 8 tipos de linhas:

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

Vamos tentar o mesmo para sua transposição.

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

Aqui, existem 10 tipos de linhas.

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

Mas aqui está o problema: os 5 inferiores são idênticos aos 5 superiores, exceto para troca /e \. De acordo com a regra anterior, você pode primeiro gerar os 5 primeiros, copiar, fazer a troca e finalmente transpor para obter a seta. Isso pode economizar muito código.

Caracteres de controle, seqüências de escape e códigos de console

A menos que a pergunta os proíba, o consenso atual sobre o Meta é que os desafios da arte ASCII não exigem um fluxo de bytes específico, mas uma saída que parece correta.

Isso significa que podemos usar caracteres de controle ASCII , seqüências de escape ANSI e códigos de console do Linux em nossas respostas, assumindo um terminal de suporte.

A menos que especificado de outra forma, o restante desta resposta explicará o comportamento dos terminais Linux, que é o que tenho disponível para teste no momento.

Caracteres de controle ASCII

O suporte / interpretação varia de terminal para terminal e de caractere para caractere. O mais portátil deve ser o avanço de linha ( \n, \x0a), que move o caractere para o início da próxima linha.

Outros caracteres úteis incluem:

• A guia vertical ( \v, \x0b) move o cursor uma posição para a direita e depois uma posição para baixo.

  $ echo -e 'a\vb'
  a
   b
  

• O retorno de carro ( \r, \x0d) move o cursor para o início da linha atual . Qualquer caractere imprimível subseqüente substituirá o primeiro caractere da linha atual.

  $ echo -e 'ab\rc'
  cb
  

• O backspace ( \b, \x08) move o cursor uma posição para a esquerda. Qualquer caractere imprimível subseqüente substituirá o caractere antes do backspace.

  $ echo -e 'ab\bc'
  ac
  

• O escape ( \e, \x1b) não faz nada por si só, mas faz parte das seqüências de escape ANSI (opcionalmente) e dos códigos do console Linux.

Muitos idiomas permitem caracteres de controle reais no código-fonte.

Sequências de escape ANSI

(ainda está por vir)

Códigos do console do Linux

Embora existam muito mais, os códigos de console mais úteis para a arte ASCII são provavelmente os seguintes:

• A sequência \ecvai repor o terminal. Isso limpa a tela, coloca o cursor no canto superior esquerdo e define a cor da frente e do fundo, a taxa de piscada do cursor etc. para seus valores padrão.

• A sequência \eMcausa um avanço de linha reverso , ou seja, o cursor se move uma posição para cima.

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

• A sequência \eHdefine a parada de tabulação na coluna atual.

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

Procure padrões

Este pode ser um pouco óbvio, mas ... procure padrões, semelhanças e repetições na saída. Por exemplo, quando vi a tarefa Transformar número em padrão de exibição de 7 segmentos, comecei a pensar em como alguém poderia jogar golfe e comecei a procurar semelhanças. Devido à maneira como os segmentos horizontais se posicionam entre os verticais na matriz de caracteres, provavelmente seria mais fácil lidar com três segmentos de cada vez, agrupados como tal (adicionando dois segmentos "sempre vazios" para o primeiro e mais alto) :

Assim, você poderia fazer algo como lc + " "*N + rc + "\n"N-1 vezes e depois lc + bc*N + rcuma vez, para cada três segmentos ( lc, bc, rcsendo os personagens esquerda, bottom e direito do segmento, ou seja um dos |, _ou  ).

Usar conversão base

Esta resposta foi para uma pergunta que queria arte ASCII, que consistia em caracteres + |-e novas linhas. Como existem apenas 5 caracteres possíveis, eles podem ser tratados como um número base 5 e convertidos em bytes, compactando 3,45 caracteres por byte.

Explorar regularidades

Frequentemente, os dados terão algumas regularidades, mesmo que essas regularidades não sejam fortes o suficiente para empregar ferramentas específicas, como espelhamento. Por exemplo, na pergunta acima, a saída desejada apresentava novas linhas aproximadamente uniformemente espaçadas ao longo do teste, já que o texto era aproximadamente retangular. Eu explorei isso para encurtar meu código, usando a função dividida em n pieces de Pyth, e então ingressando em novas linhas.

Conheça suas ferramentas e escolha a ferramenta certa para o trabalho.

As ferramentas de processamento de texto mais poderosas e eficientes que conheço são:

Motores Regex:, ///Retina, Perl, em ordem de troca de potência / concisão.

Use se o que você deseja fazer puder ser descrito conscientemente nas substituições de expressões regulares, como esta resposta

Ferramentas de processamento de texto obscuras: gema etc. (tenho certeza de que existem outras, mas são muito obscuras)

Use se eles tiverem um recurso exatamente o que você precisa, que nada mais possui. Como nesta pergunta , com a correspondência recursiva do gema.

Linguagens de golfe com códigos gerais: CJam, Pyth, etc.

Use se estiver explorando alguma sutileza complexa o suficiente para que nenhuma outra ferramenta faça o trabalho ou apenas faça o trabalho mais curto.

Tente muitas abordagens

Isso se aplica a todas as questões de código-golfe, mas especialmente aqui. Você não saberá se uma regularidade é explorável até que você a experimente. Possivelmente em vários idiomas.