Da quando ho visto più >> invii fluttuanti negli ultimi tempi, ho pensato che sarebbe stata una buona idea avere una pagina di suggerimenti.

Attenersi a un suggerimento per post, a meno che non siano strettamente correlati.

Interprete ufficiale di Python

Interprete online (alcuni bug presenti, ma buono per la maggior parte dei casi)

Verifica contro 0

Usando ?!anziché in 0=?genere si salva un byte.

Tuttavia, solo uno standard ?può talvolta essere migliore se puoi permetterti un po 'di ristrutturazione

?!vA
  B

contro

?vB
 A

Verifica di EOF

Quando viene raggiunto l'EOF,> <> inserisce un -1 nello stack, che può essere verificato in due modi:

:0(?
:1+?

Ai fini del controllo di EOF, queste due sono negazioni, quindi quale è più vantaggioso dipende dalla struttura del programma.

Salta per eludere l'avvio di nuove linee

Iniziare una nuova linea a volte significa sprecare molto spazio bianco nella riga successiva. In una situazione del genere, saltare può essere utile.

Per esempio,

[lots of code here]>[loop body]v
                   ^ ......... <

può essere fatto per adattarsi su una riga in questo modo:

[lots of code here][loop body][jump]

Per un esempio pratico, ecco il programma Hello World su una riga:

"!dlroW ,olleH"l?!;oe0.

Utilizzo del modulo per semplificare l'input

Questo potrebbe essere un suggerimento troppo semplice, quindi se lo è lo sostituirò o lo cancellerò.

Diciamo che vuoi prendere input di due caratteri, "a" e "b" e restituire 1 e 2 rispettivamente per ciascuno. Probabilmente useresti dei condizionali per questo, dal momento che ha più senso, e userò una forma più condensata per questo esempio specifico.

i:"a")+1+n

Questo controlla se l'input è maggiore di "a" e aggiunge 1. Poiché "a" restituirà 0 e "b" 1, questo darà 1 e 2. Questo fa abbastanza bene il lavoro, ma nel caso del nostro input, potremmo andare ancora oltre.

i:3%n

Nella mod 3, 97, che è l'equivalente numerico di "a", diventa 1 e 98, che è "b" s, diventa 2. Per due numeri diversi, è garantita una mod che fornisce risultati unici per entrambi. Per più di due, c'è una mod che dà risultati unici, ma non ho l'abilità matematica di trovare la più piccola in modo semplice (ad esempio se hai il set {100,101,102,103}, la mod 104 darebbe risultati unici per ogni valore in esso, ma non in modo molto utile). Tuttavia, nella maggior parte dei casi, con l'input limitato a un paio di caratteri alfabetici, puoi spesso trovare una mod che funziona.

Per trovare il modulo più piccolo che produce risultati univoci per due numeri, a, e, b, si procede come segue. Prendi il valore assoluto della differenza di aeb ( |a - b|) e trova il numero più piccolo, n, che non lo divide. ad es. per 97 e 98, |98 - 97| = 1e quindi 2 sarebbe la mod più piccola (ma per il nostro programma di test, questo dà 1 per 97 e 0 per 98, quindi la mod 3 è migliore).

Utilizzando i salti come condizionale

Alcune volte finirai per scrivere programmi in> <> che richiedono di fare cose diverse alla ricezione di input diversi. Di solito, ?per analizzare questo , dovresti usare i condizionali ( ) e i cambi di direzione. In alcuni casi, funziona benissimo (soprattutto quando ci sono meno tipi di input da gestire), ma a volte si finisce con qualcosa che assomiglia a questo. (Ignora il fatto che questo codice può essere ridotto usando altri trucchi, è solo per dimostrazione)

i:"a"=?v:"b"=?v"c"=?v>
  .00n1< .00n2<.00n3<

Mentre questo va bene, ha alcuni spazi bianchi (che personalmente non mi piace mai vedere) e ha molte ripetizioni ( =?ve .00n). Invece, potresti usare un salto e linee diverse come condizionali. Ecco un esempio:

i:"a")$"b")+1+0$.>
v1
v2
v3
<.00n

In questo modo si eliminano 10 byte. Ecco cosa sta succedendo:

i: Dupliciamo l'input una volta così possiamo valutarlo due volte

"a")$"b")+Questo potrebbe essere il suo tipo di suggerimento, ma quello che sto facendo qui è verificare se l'input è maggiore del carattere "a" e quindi se è maggiore del carattere "b" e aggiungere il risultato. Per "a", questo produrrà 0, per "b," 1 e per "c," 2.

1+0$.Qui è dove avviene la magia; prendiamo il risultato di questa precedente semplificazione e aggiungiamo 1 (dando 1 per "a", 2 per "b", 3 per "c"), quindi spingiamo 0 e scambiamo i valori. Quando raggiungiamo il salto, questo si sposterà sulla linea corrispondente al valore che abbiamo assegnato a quei caratteri (es. Linea 1 per "a"). NB La riga 0 è la parte superiore del programma.

Scrivere codice che può essere eseguito in due modi

I trampolini ( !) sono molto utili quando si desidera che il codice venga eseguito avanti e indietro (o su e giù). Questi scenari sono alquanto improbabili, ma per palindromo o sfide simili questo suggerimento potrebbe essere utile.

Ecco un esempio: voglio eseguire un po 'di codice una volta, quindi scorrere lo stack scartando i valori fino a quando non raggiungo 0, quindi scendo. Il puntatore entra in questo loop dal >. È possibile utilizzare un salto per ottenere questo risultato, ad es

?!v80.>ao (diciamo che prima voglio stampare una nuova riga)

ma se il codice che vogliamo eseguire una volta (il codice oltre il >) rende la riga più lunga di 16 caratteri, non possiamo più usare il salto in tre caratteri. Tuttavia, questo è un esempio in cui è banale correre avanti e indietro ...

?!v!?<>ao>

Andando avanti, stampiamo una nuova riga e quindi ?!vcolpiamo il quale scarta il valore se non è 0, quindi a causa del trampolino saltiamo il successivo ?e torniamo indietro. Succede la stessa cosa e il ciclo continua fino a quando non colpiamo uno 0.

Questo è un esempio stranamente specifico, ma ci sono alcune (forse non molte) applicazioni.