Je pense que les questions d'art ASCII sur PPCG sont amusantes à faire, mais personnellement, je pense que cela peut être assez difficile, surtout lorsque la question est étiquetée comme code-golf .

Je me demande si quelqu'un ici pourrait avoir des conseils qui seront utiles pour produire de l'art ASCII.

La simple organisation des caractères est facile, mais avec des algorithmes (courts), les choses deviendront plus compliquées.

Je parle de l'art ASCII comme:

• Texte en art ASCII (caractères)
• Images (logos ou icônes)

Je suis juste à la recherche de conseils généraux, mais la langue est autorisée car la plupart d'entre eux peuvent être traduits de toute façon.

Algorithmes de compression

Vous pouvez appliquer une compression LZMA à la chaîne.
De nombreuses langues le supportent.

Encodage de longueur

Vous pouvez utiliser des instructions de traitement telles que [char][number](par exemple b12).
Cet algorithme de compression est utilisé ici: /codegolf//a/20589/10920

Pour en savoir plus: http://en.wikipedia.org/wiki/Run-length_encoding

Emballage entier

Vous pouvez utiliser des tableaux d'entiers pour stocker de petites formes telles que:

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

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

Chaque espace sera traduit en a 0.
Chaque tranchant sera traduit en a 1.

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

Chaque bit est ensuite lu en utilisant l'opérateur au niveau du bit &.

L'algorithme ci-dessus pourrait être amélioré en utilisant une base entière plus grande:

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

Recherchez la symétrie

Parfois, l'art ASCII requis est symétrique à un moment donné. Par exemple, Argyle ASCII Art nécessite une sortie similaire à celle-ci:

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

On pourrait simplement l'imprimer normalement, mais selon la langue, le code requis peut être raccourci en ne générant que la moitié supérieure du résultat, en l'inversant et en échangeant /et \.

Essayez de transposer

Dans ASCII Art Archery Arrows, le résultat à imprimer est le suivant, mis à l'échelle pour une donnée n:

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

Si nous regardons la flèche, nous pouvons voir qu'il y a 8 types de lignes:

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

Essayons de même pour sa transposition.

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

Ici, il existe 10 types de lignes.

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

Mais voici le hic: les 5 derniers sont identiques aux 5 premiers, sauf pour les échanges /et \. Selon la règle précédente, vous pouvez d'abord générer les 5 premiers, copier, faire le swap et enfin transposer pour obtenir la flèche. Cela peut économiser beaucoup de code.

Contrôler les caractères, les séquences d'échappement et les codes de console

À moins que la question ne les interdise, le consensus actuel sur Meta est que les défis artistiques ASCII ne nécessitent pas un flux d'octets spécifique, mais une sortie qui semble correcte.

Cela signifie que nous pouvons utiliser des caractères de contrôle ASCII , des séquences d'échappement ANSI et des codes de console Linux dans nos réponses, en supposant un terminal de prise en charge.

Sauf indication contraire, le reste de cette réponse expliquera le comportement des terminaux Linux, ce que je peux tester actuellement.

Caractères de contrôle ASCII

Le support / interprétation varie d'un terminal à l'autre et d'un caractère à l'autre. Le plus portable devrait être le saut de ligne ( \n, \x0a), qui déplace le caractère au début de la ligne suivante.

D'autres caractères utiles incluent:

• L'onglet vertical ( \v, \x0b) déplace le curseur d'une position vers la droite, puis d'une position vers le bas.

  $ echo -e 'a\vb'
  a
   b
  

• Le retour chariot ( \r, \x0d) déplace le curseur au début de la ligne actuelle . Tout caractère imprimable ultérieur remplacera le premier caractère de la ligne actuelle.

  $ echo -e 'ab\rc'
  cb
  

• Le retour arrière ( \b, \x08) déplace le curseur d'une position vers la gauche. Tout caractère imprimable ultérieur remplacera le caractère avant le retour arrière.

  $ echo -e 'ab\bc'
  ac
  

• L'évasion (\e , \x1b) ne fait rien à elle seule, mais fait partie des séquences d'échappement ANSI (en option) et des codes de console Linux.

De nombreuses langues autorisent les caractères de contrôle réels dans le code source.

Séquences d'échappement ANSI

(encore à venir)

Codes de console Linux

Bien qu'il y en ait beaucoup plus, les codes de console les plus utiles pour l'art ASCII sont probablement les suivants:

• La séquence \ecva réinitialiser le terminal. Cela efface l'écran, place le curseur dans le coin supérieur gauche et définit la couleur d'avant et d'arrière-plan, le taux de clignotement du curseur, etc. à leurs valeurs par défaut.

• La séquence \eMprovoque un saut de ligne inverse , c'est-à-dire que le curseur se déplace d'une position vers le haut.

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

• La séquence \eHdéfinit le taquet de tabulation dans la colonne actuelle.

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

Rechercher des motifs

Celui-ci peut être un peu évident, mais ... recherchez des motifs, des similitudes et des répétitions dans la sortie. Par exemple, quand j'ai vu le numéro de transformation en tâche d' affichage à 7 segments, j'ai commencé à réfléchir à la façon de jouer au golf et j'ai commencé à chercher des similitudes. En raison de la façon dont les segments horizontaux vont entre les segments verticaux dans la matrice de caractères, il serait probablement plus facile de traiter trois segments à la fois, regroupés comme tels (en ajoutant deux segments "toujours vides" pour le premier, le plus haut) :

Ainsi, vous pouvez faire quelque chose comme lc + " "*N + rc + "\n"N-1 fois, puis lc + bc*N + rcune fois, pour tous les trois segments ( lc, bc, rcétant les gauche, de bas en et caractères à droite segments, soit l' un des |, _ou  ).

Utiliser la conversion de base

Cette réponse était à une question qui voulait de l'art ASCII composé des personnages + |-et des nouvelles lignes. Puisqu'il n'y a que 5 caractères possibles, ceux-ci peuvent être traités comme un nombre de base 5 et convertis en octets, emballant 3,45 caractères par octet.

Exploiter les régularités

Souvent, les données auront certaines régularités, même si ces régularités ne sont pas assez fortes pour utiliser des outils spécifiques tels que la mise en miroir. Par exemple, dans la question ci-dessus, la sortie souhaitée avait des nouvelles lignes à peu près également espacées tout au long du test, car le texte était à peu près rectangulaire. J'ai exploité cela pour raccourcir mon code, en utilisant la fonction de scission de Pyth en n morceaux, puis en se joignant à des nouvelles lignes.

Connaissez vos outils et choisissez celui qui vous convient.

Les outils de traitement de texte les plus puissants et efficaces que je connaisse sont:

Moteurs Regex: /// Retina, Perl, par ordre de compromis puissance / concision.

À utiliser si la chose que vous voulez faire peut être décrite consciencieusement dans des substitutions d'expression régulière, telles que cette réponse

Outils de traitement de texte obscurs: gema, etc. (je suis sûr qu'il y en a d'autres, mais ils sont trop obscurs)

Utilisez-les s'ils ont une fonctionnalité qui correspond exactement à ce dont vous avez besoin, que rien d'autre n'a. Comme dans cette question , avec l'appariement récursif de gema.

Langages de golf à code général: CJam, Pyth, etc.

À utiliser si vous exploitez un complexe suffisamment subtil pour qu'aucun autre outil ne fasse le travail ou qu'il le fasse plus court.

Essayez de nombreuses approches

Cela s'applique à chaque question de code-golf, mais surtout ici. Vous ne saurez pas si une régularité est exploitable avant de l'essayer. Peut-être en plusieurs langues.