Il carbone di legna è un linguaggio creato solo da ASCII e DLosc specializzato in sfide artistiche ASCII.

Che consigli hai per giocare a golf in Carbone? Ovviamente sto cercando consigli relativi specificamente al carbone, non quelli che possono essere applicati alla maggior parte - se non a tutte le lingue.

Approfitta del deverbosificatore

L'uso del deverbosificatore significa che è possibile scrivere in ASCII ( --dvo --deverbosifydeverbosificare -vo --verboseeseguire come codice dettagliato). Inoltre, comprime le stringhe per te, il che può essere utile in alcune sfide di arte ASCII quando la stringa da comprimere è troppo lunga.

@Neil consiglia di utilizzare -vlo -v --sl. Questo è l'abbreviazione di --verbose --showlength, nel senso che verrà interpretato come carbone dettagliato, e verrà mostrata la lunghezza del normale codice carbone. Inoltre, durante la deverbosificazione, controllare l'output per assicurarsi che l'input sia stato effettivamente analizzato correttamente, poiché il carbone generalmente ignora gli errori di analisi. Se c'è un errore di sintassi, l'uso -a( --astify) o --oa( --onlyastify) per aiutare a capire il problema.

Usa sovraccarichi

Ad esempio, molti comandi richiedono solo un argomento:

• Rectangle, OblongE Boxfare un quadrato se viene dato solo argomento
• Reflect i comandi di default riflettono a destra
• Rotate i comandi sono predefiniti a 90 gradi in senso antiorario
• Polygone PolygonHollowpuò accettare una lunghezza multidirezionale e laterale. Questo può essere usato se tutti i lati hanno la stessa lunghezza.

Evita costanti consecutive dello stesso tipo

Ad esempio, Plus(Times(i, 2), 1)traduce come ⁺×鲦¹, ma puoi salvare un byte cambiando i parametri: Plus(1, Times(i, 2))traduce come ⁺¹×ι²e Plus(Times(2, i), 1)come ⁺ײι¹entrambi salvano un byte. Plus(1, Times(2, i))(che si traduce in ⁺¹×²ι) sarebbe ancora meglio se ci fosse un'altra costante numerica che la seguiva.

Usa le variabili predefinite

Ecco un elenco di tutte le variabili che possono essere utilizzate, fornendo la lettera greca sintetica e la lettera verbosa che la rappresenta.

α/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

Le variabili che rappresentano gli input saranno vuote se non esiste abbastanza input, ma tutte le altre variabili non mostrate qui devono essere assegnate prima dell'uso.

Scopri i tuoi riflessi e rotazioni

Esistono molte variazioni della riflessione e della rotazione di base, quindi è utile sapere quali sono le sottili differenze. Chiave per le tabelle:

• Comando: nome del comando in modalità dettagliata.
• Trasforma: se il carbone deve tentare di capovolgere o ruotare i personaggi mentre li rispecchia o li ruota. Ad esempio, a /potrebbe diventare\ dopo una rotazione o capovolgere.
• Mantieni originale: se il carbone deve unire il risultato con la tela originale.
• Sovrapposizione: (vale solo quando Mantieni originale è Sì.) Determina la posizione dell'asse di riflessione / rotazione, a mezzo carattere dal bordo. Nel caso delle riflessioni, equivalente al numero di righe / colonne che non sono interessate e finiscono nel mezzo del risultato. Nel caso di rotazioni, la copia ruotata può sovrascrivere aree chiare (ma non spazi) nell'originale.

Riflessi

|         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 direzione della riflessione è facoltativa. L'impostazione predefinita è riflettere una volta a destra. Per quei riflessi che mantengono l'originale, è consentita una direzione multipla, che semplicemente ripete il comando per ogni direzione. (Questo significa ad esempioReflectMirror(:¬) , in realtà creerà quattro copie in totale.)

Il cursore viene spostato insieme al riflesso (anche quando l'originale viene mantenuto).

rotazioni

|         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       |

Per quelle rotazioni che mantengono l'originale, esiste un'origine opzionale di rotazione. L'impostazione predefinita è in basso a destra nell'area di disegno. I valori consentiti sono una qualsiasi delle direzioni diagonali.

La quantità di rotazione (con incrementi di 45 °) è facoltativa. L'impostazione predefinita è 2, ovvero 90 ° in senso antiorario (antiorario). Per quelle rotazioni che mantengono l'originale, ci sono due opzioni alternative: un intero a più cifre specifica di ruotare la tela una volta per ogni cifra e quindi unire i risultati, mentre un elenco di numeri interi semplicemente ripete il comando per ogni rotazione, con risultati variabili a seconda di come la tela cambia nel mezzo.

Utilizzare i comandi senza un carattere di comando

Viene stampata un'espressione che non fa parte di un comando.
Se è preceduto da una direzione, l'espressione viene stampata nella direzione specificata.
I numeri sono stampati come una linea con la lunghezza specificata usando un carattere selezionato da \/-|.

Se una direzione non è seguita da un'espressione, viene conteggiata come uno spostamento di uno spazio nella direzione specificata.

Nota: questo a volte può essere conteggiato come parte del comando precedente, quindi il carattere del comando potrebbe essere effettivamente richiesto. (grazie Neil per avermelo ricordato)

Usa multidirezionali

Alcuni comandi possono accettare multidirectionals: +X*|-\/<>^KLTVY7¬⌊⌈. Ciò a cui si espandono sono qui . In generale, l'elenco delle direzioni inizia dall'alto e continua in senso orario.

Fare pieno uso di Sum

Sum ha molti sovraccarichi utili:

• In un elenco di stringhe, le concatena insieme. Tuttavia, se è possibile che l'elenco sia vuoto, questo darebbe Nessuno, quindi in questo caso, utilizzare Join(..., "")invece.
• Su un elenco di numeri non vuoto, prende semplicemente la loro somma.
• In un elenco non vuoto di elenchi, li concatena insieme (si appiattisce alla profondità 1).
• Su un numero intero, prende la somma delle sue cifre. (I valori in virgola mobile vengono troncati a numeri interi. Se si desidera la somma delle posizioni decimali, eseguire prima il cast su stringa.)
• Su una stringa contenente solo cifre e facoltativamente un .carattere, prende la somma delle cifre.
• Su una stringa contenente numeri e separatori, prende la somma dei numeri espressi in int o float (ma nota che -conta come separatore).

Un comodo effetto collaterale delle ultime due regole è che se si utilizza Sumun personaggio, le cifre 1-9vengono espresse sul loro valore e tutto il resto restituisce zero, a differenza Cast, che non riesce per valori non numerici.

Usa split per un array di stringhe, split e cast per un array di numeri

La divisione per un array di stringhe è composta solo da tre caratteri di sovraccarico e la divisione e il cast sono solo quattro caratteri di sovraccarico. Confronta questo con la scrittura dell'array letteralmente, che richiederebbe l'inizio e la fine dell'array e un separatore tra ogni elemento dell'array.

Se il tuo array di numeri ha solo numeri inferiori a 95, usa un cast (se tutti i numeri sono inferiori a 10) o indicizza in una delle variabili predefinite.

Utilizzare il filtro per tagliare il primo carattere da un array o una stringa

Anche se sei fortunato, usando Slice per tagliare il primo carattere da una stringa prende 2 byte: Slice(..., 1). Ci vorrà più tempo se l'espressione da dividere termina in un numero, richiedendo un separatore, o se il seguente codice può essere interpretato come espressione, poiché in quel caso Slicevorrà utilizzarlo come parametro aggiuntivo.

Invece, basta usare Filter(..., k), che rilascia il primo elemento, ottenendo così il risultato desiderato. (Ovviamente usa la variabile indice del ciclo appropriata se la tua espressione è nidificata all'interno di un altro ciclo.) Questo è sempre di 2 byte e non può essere influenzato dal codice circostante.