Penso che le domande sull'arte ASCII su PPCG siano divertenti da fare, ma personalmente penso che possa essere piuttosto difficile, specialmente quando la domanda è taggata come code-golf .

Mi chiedo se qualcuno qui potrebbe avere alcuni suggerimenti che saranno utili per produrre arte ASCII.

Disporre semplicemente i personaggi è facile, ma con algoritmi (brevi) le cose diventeranno più complicate.

Sto parlando di arte ASCII come:

• Testo in ASCII art (caratteri)
• Immagini (loghi o icone)

Sto solo cercando consigli generali, ma è consentito l'uso di una lingua specifica poiché la maggior parte di essi può essere tradotta comunque.

Algoritmi di compressione

È possibile applicare la compressione LZMA alla stringa.
Molte lingue lo supportano.

Codifica run-length

È possibile utilizzare istruzioni di elaborazione come [char][number](ad esempio b12).
Questo algoritmo di compressione viene utilizzato qui: /codegolf//a/20589/10920

Ulteriori letture: http://en.wikipedia.org/wiki/Run-length_encoding

Imballaggio intero

È possibile utilizzare matrici di numeri interi per memorizzare piccole forme come:

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

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

Ogni spazio verrà tradotto in a 0.
Ogni sharp sarà tradotto in a 1.

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

Ogni bit viene quindi letto usando l'operatore bitwise & .

L'algoritmo sopra potrebbe essere migliorato usando una base intera più grande:

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

Cerca simmetria

A volte l'arte ASCII richiesta è simmetrica ad un certo punto. Ad esempio, Argyle ASCII Art richiede un output simile al seguente:

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

Si potrebbe semplicemente stampare questo normalmente, ma a seconda della lingua, il codice richiesto può essere abbreviato generando solo la metà superiore del risultato, invertendolo, scambiandolo /e \.

Prova a trasporre

In ASCII Art Archery Arrows il risultato da stampare è questo, ridimensionato in base a un dato n:

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

Se diamo uno sguardo alla freccia, possiamo vedere che ci sono 8 tipi di linee:

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

Proviamo lo stesso per la sua trasposizione.

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

Qui ci sono 10 tipi di linee.

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

Ma ecco il trucco: i 5 inferiori sono identici ai primi 5, tranne che per lo scambio /e \. Come da regola precedente, puoi prima generare i primi 5, copiare, fare lo scambio e infine trasporre per ottenere la freccia. Questo può salvare molto codice.

Controlla personaggi, sequenze di escape e codici console

A meno che la domanda non li proibisca, l'attuale consenso su Meta è che le sfide dell'arte ASCII non richiedono un flusso di byte specifico, ma un output che sembra corretto.

Ciò significa che possiamo usare caratteri di controllo ASCII , sequenze di escape ANSI e codici console Linux nelle nostre risposte, assumendo un terminale di supporto.

Se non diversamente specificato, il resto di questa risposta spiegherà il comportamento dei terminali Linux, che è ciò che ho disponibile per il test in questo momento.

Caratteri di controllo ASCII

Il supporto / interpretazione varia da terminale a terminale e da carattere a carattere. Il più portatile dovrebbe essere il linefeed ( \n,\x0a ), che sposta il personaggio all'inizio della riga successiva.

Altri personaggi utili includono:

• La scheda verticale ( \v, \x0b) sposta il cursore di una posizione verso destra, quindi di una posizione verso il basso.

  $ echo -e 'a\vb'
  a
   b
  

• Il ritorno a capo ( \r, \x0d) sposta il cursore all'inizio della riga corrente . Qualsiasi carattere stampabile successivo sovrascriverà il primo carattere della riga corrente.

  $ echo -e 'ab\rc'
  cb
  

• Il backspace ( \b, \x08) sposta il cursore di una posizione verso sinistra. Qualsiasi carattere stampabile successivo sovrascriverà il carattere prima del backspace.

  $ echo -e 'ab\bc'
  ac
  

• L'escape ( \e, \x1b) non fa nulla da solo, ma fa parte delle sequenze di escape ANSI (opzionalmente) e dei codici della console Linux.

Molte lingue consentono caratteri di controllo effettivi nel codice sorgente.

Sequenze di escape ANSI

(ancora da venire)

Codici console Linux

Mentre ce ne sono molti altri, i codici console più utili per l'arte ASCII sono probabilmente questi:

• La sequenza \ecsarà resettare il terminale. Questo cancella lo schermo, sposta il cursore nell'angolo in alto a sinistra e imposta il colore di sfondo e di sfondo, la frequenza di lampeggiamento del cursore, ecc. Sui loro valori predefiniti.

• La sequenza \eMprovoca un avanzamento di riga inverso , ovvero il cursore si sposta di una posizione verso l'alto.

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

• La sequenza \eHimposta il punto di tabulazione nella colonna corrente.

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

Cerca modelli

Questo potrebbe essere un po 'ovvio, ma ... cerca schemi, somiglianze e ripetizioni nell'output. Ad esempio, quando ho visto il numero di trasformazione in un'attività di visualizzazione a 7 segmenti, ho iniziato a pensare a come si potesse giocare a golf e ho iniziato a cercare somiglianze. A causa del modo in cui i segmenti orizzontali si spostano tra quelli verticali nella matrice del personaggio, sarebbe probabilmente più semplice gestire tre segmenti alla volta, raggruppati come tali (aggiungendo due segmenti "sempre vuoti" per il primo, quello più in alto) :

Così, si potrebbe fare qualcosa di simile a lc + " "*N + rc + "\n"N-1 volte e poi lc + bc*N + rcuna volta, per ogni tre segmenti ( lc, bc, rcessendo i caratteri a sinistra, dal basso, a destra e segmenti, vale a dire uno dei |, _o  ).

Usa la conversione di base

Questa risposta era a una domanda che voleva l'arte ASCII che consisteva nei personaggi + |-e nelle nuove linee. Poiché ci sono solo 5 caratteri possibili, questi possono essere trattati come un numero di base 5 e convertiti in byte, comprimendo 3,45 caratteri per byte.

Sfruttare le regolarità

Spesso, i dati avranno alcune regolarità, anche se tali regolarità non sono abbastanza forti da impiegare strumenti specifici come il mirroring. Ad esempio, nella domanda di cui sopra, l'output desiderato aveva una nuova linea approssimativamente distribuita uniformemente durante il test, poiché il testo era approssimativamente rettangolare. L'ho sfruttato per abbreviare il mio codice, usando la funzione divisa in n pezzi di Pyth, quindi unendomi a nuove righe.

Conosci i tuoi strumenti e scegli quello giusto per il lavoro.

Gli strumenti di elaborazione del testo più potenti ed efficienti che conosco sono:

Motori Regex:, ///Retina, Perl, in ordine di potenza / compromesso conciso.

Usa se la cosa che vuoi fare può essere descritta in modo conscio nelle sostituzioni regex, come questa risposta

Strumenti di elaborazione del testo oscuri: gema, ecc. (Sono sicuro che ce ne sono altri, ma sono troppo oscuri)

Usa se hanno una funzione che è esattamente ciò di cui hai bisogno, che nient'altro ha. Come in questa domanda , con la corrispondenza ricorsiva della gema.

Linguaggi di golf con codice generale: CJam, Pyth, ecc.

Utilizzare se si sta sfruttando una sottigliezza abbastanza complessa da non consentire a nessun altro strumento di eseguire il lavoro o di accorciare il lavoro.

Prova molti approcci

Questo vale per ogni domanda di code-golf, ma soprattutto qui. Non saprai se una regolarità è sfruttabile fino a quando non la provi. Forse in più lingue.