Le charbon de bois est un langage créé par ASCII uniquement et DLosc qui se spécialise dans les défis artistiques ASCII.

Quels conseils avez-vous pour jouer au golf au charbon de bois? Évidemment, je suis à la recherche de conseils concernant spécifiquement le charbon de bois, pas ceux qui peuvent être appliqués à la plupart, sinon à toutes les langues.

Profitez du déverbosifiant

L'utilisation du déverbosificateur signifie que vous pouvez écrire en ASCII ( --dvou --deverbosifypour déverbosifier -vou --verbosepour exécuter en tant que code détaillé). De plus, il compresse les chaînes pour vous, ce qui peut être utile dans certains défis de l'art ASCII lorsque la chaîne à compresser est trop longue.

@Neil recommande d'utiliser -vlou -v --sl. Ceci est court pour --verbose --showlength, ce qui signifie qu'il sera interprété comme du charbon de bois verbeux, et la longueur du code de charbon de bois normal sera affichée. De plus, lors de la déverbosification, vérifiez la sortie pour vous assurer que l'entrée a bien été analysée correctement, car Charcoal ignore généralement les erreurs d'analyse. S'il est une erreur de syntaxe, l' utilisation -a( --astify) ou --oa( --onlyastify) à la figure de l' aide sur le problème.

Utiliser des surcharges

Par exemple, de nombreuses commandes n'ont besoin que d'un seul argument:

• Rectangle, Oblonget Boxfaites un carré si un seul argument est donné
• Reflect commandes par défaut pour refléter vers la droite
• Rotate commandes par défaut à 90 degrés dans le sens antihoraire
• Polygonet PolygonHollowpeut accepter une longueur multidirectionnelle et latérale. Cela peut être utilisé si tous les côtés sont de la même longueur.

Évitez les constantes consécutives du même type

Par exemple, Plus(Times(i, 2), 1)traduit comme ⁺×鲦¹, mais vous pouvez enregistrer un octet en changeant les paramètres: Plus(1, Times(i, 2))traduit comme ⁺¹×ι²et Plus(Times(2, i), 1)comme ⁺ײι¹tous les deux enregistrent un octet. Plus(1, Times(2, i))(qui se traduit par ⁺¹×²ι) serait encore mieux s'il y avait une autre constante numérique qui la suivait.

Utilisez les variables prédéfinies

Voici une liste de toutes les variables qui peuvent être utilisées, en donnant la lettre grecque succincte et la lettre verbeuse qui la représente.

α/a: The uppercase alphabet
β/b: The lowercase alphabet
γ/g: A string of all the ASCII characters from space to ~
δ/d: The fifth input
ε/e: The fourth input
ζ/z: The third input
η/h: The second input
θ/q: The first input
υ/u: An empty array
φ/f: 1000
χ/c: 10
ψ/y: The null character
ω/w: The empty string

Les variables représentant les entrées seront vides s'il n'y a pas suffisamment d'entrées, mais toutes les autres variables non présentées ici doivent être affectées avant utilisation.

Apprenez vos réflexions et rotations

Il existe de nombreuses variations de la réflexion et de la rotation de base, il est donc avantageux de savoir quelles sont les différences subtiles. Légende des tableaux:

• Commande: nom de la commande en mode verbeux.
• Transformer: si le charbon de bois doit tenter de retourner ou de faire pivoter les personnages en les reflétant ou en les faisant pivoter. Par exemple, un /pourrait devenir \après une rotation ou un retournement.
• Conserver l'original: indique si le fusain doit fusionner le résultat avec la toile d'origine.
• Chevauchement: (s'applique uniquement lorsque Conserver l'original est Oui.) Détermine la position de l'axe de réflexion / rotation, en demi-caractères à partir de la bordure. Dans le cas des réflexions, équivalent au nombre de lignes / colonnes qui ne sont pas affectées et se retrouvent au milieu du résultat. Dans le cas de rotations, la copie pivotée est autorisée à remplacer les zones claires (mais pas les espaces) de l'original.

Réflexions

|         Command         | Transform | Keep Original | Overlap |
|-------------------------|-----------|---------------|---------|
| Reflect                 | No        | No            | n/a     |
| ReflectCopy             | No        | Yes           | 0       |
| ReflectOverlap          | No        | Yes           | 1       |
| ReflectOverlapOverlap   | No        | Yes           | n       |
| ReflectTransform        | Yes       | No            | n/a     |
| ReflectMirror           | Yes       | Yes           | 0       |
| ReflectButterfly        | Yes       | Yes           | 1       |
| ReflectButterflyOverlap | Yes       | Yes           | n       |

La direction de réflexion est facultative. La valeur par défaut est de réfléchir une fois à droite. Pour les réflexions qui conservent l'original, une direction multiple est autorisée, qui répète simplement la commande pour chaque direction. (Cela signifie que, par exemple, ReflectMirror(:¬)va en fait créer quatre copies au total.)

Le curseur est déplacé avec la réflexion (même lorsque l'original est conservé).

Rotations

|         Command         | Transform | Keep Original | Overlap |
|-------------------------|-----------|---------------|---------|
| Rotate                  | No        | No            | n/a     |
| RotateCopy              | No        | Yes           | 0       |
| RotateOverlap           | No        | Yes           | 1       |
| RotateOverlapOverlap    | No        | Yes           | n       |
| RotateTransform         | Yes       | No            | n/a     |
| RotatePrism             | Yes       | Yes           | 0       |
| RotateShutter           | Yes       | Yes           | 1       |
| RotateShutterOverlap    | Yes       | Yes           | n       |

Pour les rotations qui conservent l'original, il existe une origine de rotation facultative. La valeur par défaut est en bas à droite du canevas. Les valeurs autorisées sont l'une des directions diagonales.

La quantité de rotation (par incréments de 45 °) est facultative. La valeur par défaut est 2, c'est-à-dire 90 ° dans le sens antihoraire (anti-horaire). Pour les rotations qui conservent l'original, il existe deux options alternatives: un entier à plusieurs chiffres spécifie de faire pivoter le canevas une fois pour chaque chiffre, puis de fusionner les résultats, tandis qu'une liste entière répète simplement la commande pour chaque rotation, avec des résultats variables selon la façon dont la toile change entre les deux.

Utiliser des commandes sans caractère de commande

Une expression qui ne fait pas partie d'une commande est imprimée.
Si elle est précédée d'une direction, l'expression est imprimée dans la direction spécifiée.
Les nombres sont imprimés sous forme de ligne avec la longueur spécifiée à l'aide d'un caractère sélectionné parmi \/-|.

Si une direction n'est pas suivie d'une expression, elle est comptée comme un déplacement d'un espace dans la direction spécifiée.

Remarque: Cela peut parfois être compté comme faisant partie de la commande précédente, de sorte que le caractère de commande peut en fait être requis. (merci Neil de me l'avoir rappelé)

Utiliser des multidirectionnels

Certaines commandes peuvent accepter multidirectionals: +X*|-\/<>^KLTVY7¬⌊⌈. Ce qu'ils développent sont ici . En général, la liste des directions commence à partir du haut et continue dans le sens horaire.

Utiliser pleinement Sum

Sum a beaucoup de surcharges pratiques:

• Sur une liste de chaînes, les concatène ensemble. Cependant, s'il est possible que la liste soit vide, cela donnerait None, donc dans ce cas, utilisez Join(..., "")plutôt.
• Sur une liste de nombres non vide, prend simplement leur somme.
• Sur une liste de listes non vide, les concatène ensemble (s'aplatit à la profondeur 1).
• Sur un entier, prend la somme de ses chiffres. (Les valeurs à virgule flottante sont tronquées en entier. Si vous voulez la somme des décimales, convertissez-la en chaîne en premier.)
• Sur une chaîne contenant uniquement des chiffres et éventuellement un .caractère, prend la somme des chiffres.
• Sur une chaîne contenant des nombres et des séparateurs, prend la somme des nombres exprimés en entier ou flottant (mais notez que cela -compte comme un séparateur).

Un effet secondaire pratique des deux dernières règles est que si vous utilisez Sumun caractère, les chiffres 1-9sont convertis à leur valeur et tout le reste renvoie zéro, contrairement à Castce qui échoue pour les valeurs non numériques.

Utilisez split pour un tableau de chaînes, split et cast pour un tableau de nombres

Le fractionnement pour un tableau de chaînes ne comporte que trois caractères de surcharge, et le fractionnement et la conversion ne sont que quatre caractères de surcharge. Comparez cela à l'écriture littérale du tableau, ce qui nécessiterait le début et la fin du tableau, et un séparateur entre chaque élément du tableau.

Si votre tableau de nombres ne contient que des nombres inférieurs à 95, utilisez soit un transtypage (si tous les nombres sont inférieurs à 10) soit un index dans l'une des variables prédéfinies.

Utilisez Filtre pour couper le premier caractère d'un tableau ou d'une chaîne

Même si vous êtes chanceux, en utilisant Slicepour trancher le premier caractère d'une chaîne prend 2 octets: Slice(..., 1). Cela prendra plus de temps si l'expression à découper se termine par un nombre, nécessitant un séparateur, ou si le code suivant peut être interprété comme une expression, comme dans ce cas Slice, vous voudrez la consommer comme paramètre supplémentaire.

Au lieu de cela, utilisez simplement Filter(..., k), qui supprime le premier élément, obtenant ainsi le résultat souhaité. (Évidemment, utilisez la variable d'index de boucle appropriée si votre expression est imbriquée dans une autre boucle.) Elle est toujours de 2 octets et ne peut pas être affectée par le code environnant.