Hai qualche consiglio per giocare a code-golf in 05AB1E , una lingua per il golf creata da Adnan ?

I tuoi suggerimenti dovrebbero essere almeno in qualche modo specifici per 05AB1E.

Si prega di inviare un suggerimento per risposta.

Dal momento che non faceva parte del Wiki nelle pagine GitHub di 05AB1E (penso che dovrebbe), lo aggiungerò qui ora solo per capirlo da solo.

Come usare il dizionario?

05AB1E ha il seguente file di dizionario words.ex contenente tutte le parole che conosce. Ma come possiamo accedere alle parole in questo dizionario? Prendiamo la parola "testing"come esempio:

"testing"è disponibile nella riga 1453 del file del dizionario. Poiché le prime due righe non sono parole e abbiamo bisogno della parola con indice 0, sottraggiamo 3.
Quindi, ora abbiamo l'indice ( 1450), ma come usarlo?

Apriamo e iniziamo una stringa compressa con “† . Diamo quindi un'occhiata alla seconda colonna del file info.txt . (Così €è 00; ‚è 01; ecc.)
Nel caso di "testing"questo significa î(14) e »(50).

La stringa compressa per "testing"è quindi: “ Provala online. Come con quasi tutti i pezzi di codice 05AB1E, il trailing “è facoltativo se non si accede alla stringa, quindi anche in questo caso senza funzioni .

Alcune cose da notare:

Tutti i caratteri che non hanno alcun indice nel file info.txt possono essere usati così come sono. Questo può essere utile per aggiungere un sper produrre un plurale anziché una parola singola o usare la punteggiatura come ,.?!ad esempio.
ÿ(interpolazione di stringhe) può essere utilizzato anche quando si desidera inserire valori dallo stack all'interno della stringa.
NOTA: ogni carattere sciolto che non ha alcun indice nel file info.txt conta come una parola per i tipi di compressione di seguito.

† Esistono diversi tipi di stringhe compresse che puoi utilizzare:

• ': Accetta una sola parola compressa così com'è (non è 'richiesto il trascinamento ) - 'î»: "testing"
• „: Accetta due parole compresse con delimitatore di spazio (non è „richiesto il trascinamento ) - „î»î»: "testing testing"
• …: Accetta tre parole compresse con delimitatore di spazio (non è …richiesto il trascinamento ) - …î»î»î»: "testing testing testing"
• “: Accetta la stringa compressa con delimitatore di spazio - “î»î»“: "testing testing"
• ’: Accetta la stringa compressa così com'è senza spazi impliciti - ’î»î»’: "testingtesting"
• ”: Accetta la stringa compressa in title-case con delimitatore di spazio - ”î»î»”: "Testing Testing"
• ‘: Prende la stringa compressa in maiuscolo con delimitatore di spazio - ‘î»î»‘: "TESTING TESTING"

Ecco un utile programma per ottenere la stringa compressa basata su un input di parole delimitato da spazi:

'“? lAð«Ã#¸˜ vyU "€‚ƒ„…†‡ˆ‰Š‹ŒŽ•–—™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï" Dâ vy"“ÿ“".V XlQi y?1#] '“,

Provalo online.

Questo programma:

1. Prendi l'input come minuscolo, rimuove tutti i caratteri non alfabetici (tranne gli spazi), quindi divide le parole per spazi ( lAð«Ã#) o racchiude le parole in un elenco se è stata inserita solo una parola ( ¸˜)
2. Passa sopra ogni parola ( vyU)
3. Quindi ha un ciclo interno su ogni parola compressa dal dizionario ( "€...ï"Dâvy), che tenterà di eseguire come programma 05AB1E ( "“ÿ“".V)
4. E se è uguale alla parola corrente, la stampa e interrompe il ciclo interno XlQiy?1#

Con un input good bye worldl'output sarebbe quindi “‚¿Þ¡‚ï“. Provalo online.

NOTA: dovresti comunque vedere se la parola esiste nel dizionario per far funzionare questo generatore e ignorerà tutti i caratteri speciali o le parole plurali. Verranno trovate solo le parole esattamente uguali nel dizionario.

Ecco un esempio in cui utilizzo …Ÿ™‚ï!la stringa "ciao mondo!" e ’‚¿Þ¡ ÿ ‚ï!’per la stringa "addio ÿ mondo!". Nota come vengono usati gli spazi e il punto esclamativo così com'è, perché non hanno indici nel file info.txt. Inoltre, usa ÿper inserire il "crudele" che era in cima allo stack, che purtroppo non faceva parte del dizionario (ma era ancora compresso usando il metodo nella sezione seguente).

Come comprimere le stringhe che non fanno parte del dizionario?

Sebbene il file del dizionario words.ex sia piuttosto grande (10.000 parole per l'esattezza), può capitare che tu abbia bisogno di una parola che non fa parte di essa, o di una stringa che è semplicemente incomprensibile. Quindi c'è un modo per comprimere anche quelli?
Esiste certamente, usando .•, che è una stringa compressa basata sull'alfabeto base-255. NOTA: questo metodo può essere utilizzato solo per i caratteri dell'alfabeto minuscolo e degli spazi.

Ecco un utile programma per convertire una parola / stringa nella stringa compressa basata sull'alfabeto base-255:

vAyk})> 27β 255B ".•ÿ•"

Provalo online. .

Ciò che fa questo programma sopra è:

• vAyk})>: Prende gli indici alfabetici a 1 indice delle singole lettere dell'input, con gli spazi che diventano indice 0
• 27β: Converti questi indici dalla base 27 a un singolo numero
• 255B: Convertire questo numero in Base-255 utilizzando la tabella codici di 05AB1E
• ".•ÿ•": Posiziona un carattere iniziale .•e finale •prima di questa stringa compressa

Ecco una risposta di esempio in cui @Kaldo utilizza .•zíΘ•per comprimere la parola "oca".

Come comprimere numeri interi grandi?

Diciamo che vogliamo usare un numero molto grande per qualcosa, ma non può davvero essere recuperato dai calcoli Pow. Ad esempio, supponiamo di voler accedere al numero intero grande 18238098189071058293per qualsiasi motivo.

In questo caso, possiamo usare sia un carattere iniziale sia uno finale •per comprimere un numero nel formato [1-9][0-9]+.
Il numero di esempio sopra diventerà •15Y₁Ò'Θpc•. Provalo online. Ancora una volta, proprio come con la stringa di dizionario compressa, il trailing •può essere rimosso facoltativamente .

Facoltativamente, quando l'intero è abbastanza piccolo, quindi è necessario utilizzare solo 2 caratteri compressi, possiamo Žinvece utilizzare , nel qual caso non avremo bisogno di un byte finale per chiuderlo e l'intero sarà compresso in 3 byte anziché in 4. Per ad esempio, si 13562otterrebbe il numero intero •rl•, ma poiché utilizza solo due caratteri, può essere Žrlinvece.

Inoltre, i numeri nell'intervallo [101, 355]possono essere compressi in 2 byte utilizzando Ƶpiù un carattere aggiuntivo dalla tabella codici di 05AB1E. Quindi, ad esempio, Ƶ–può essere utilizzato per l'intero 250. Ecco una panoramica di tutti i numeri disponibili. Questi caratteri vengono convertiti da Base-255 a Base-10 e quindi viene aggiunto 101 (poiché i numeri nell'intervallo [0,100]sono già 1 o 2 byte).

Come sono 15Y₁Ò'Θpce rlcreati? Molto semplice, il numero viene convertito in Base-255 usando la tabella codici di 05AB1E. Così si può utilizzare il seguente programma per ottenere un numero compressa, per i quali sarà quindi utilizzare Ƶ., Ž..oppure •...•a seconda delle dimensioni del numero intero compressa:

101 355Ÿså i 101-255B"Ƶÿ" ë 255B Dg2Qi "Žÿ" ë "•ÿ•"

Provalo online.

Ecco una risposta di esempio in cui @Emigna utilizza •3Èñ•per l'intero 246060.

Come comprimere gli elenchi di numeri interi?

A volte vuoi comprimere un intero elenco di numeri interi anziché un singolo numero. Ad esempio, supponiamo che vogliamo l'elenco [5,93,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81]per qualsiasi motivo. In questo caso, invece, possiamo utilizzare quanto segue: •4βŸ{©£MG]q‡dZΘp•94в Provalo online.

Ecco un utile programma per generare sia questo numero compresso che la Base in cui vogliamo convertire:

Z>© β 255B ®s"•ÿ•ÿв"

Provalo online.

Ciò che fa questo programma sopra è:

• Z>: Ottieni il numero massimo + 1 dell'elenco di input ( ©: e memorizzalo nel registro)
• β: Converte l'elenco di input dalla base max+1in un singolo numero
• 255B: Comprimi questo singolo numero (come abbiamo fatto nella sezione sopra)
• ®s"•ÿ•ÿв": Restituisce il risultato nel formato: iniziale •, numero compresso •, max + 1, finaleв

Ecco una risposta di esempio in cui utilizzo •4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91вper comprimere l'elenco [85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84].
PS: In questa risposta •6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-ø`JδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ôc'è un'alternativa di uguali byte (57), poiché tutti i numeri hanno esattamente due cifre. In alcuni casi (soprattutto piccoli elenchi) questa può essere un'alternativa più breve.

Compressione integer vs compressione elenco integer:

Con questi due può andare in entrambi i modi. A volte un elenco compresso è più corto, a volte un numero intero compresso, a volte un'alternativa completamente diversa è più breve. Quindi usa sempre il tuo giudizio e le tue abilità di golf per possibilmente giocare a golf ulteriormente, invece di affidarti completamente ai generatori di cui sopra. Ecco alcuni esempi:

[44, 59]( utilizzato in questa risposta di @Emigna ):

• •A–•60в è 7 byte (generato dal generatore di elenco di numeri interi compressi)
• •H|•2ôo •H|•2äo hardcoded 44 59‚sono tutti e 6 i byte
• ŽH|2ôo ŽH|2äsono entrambi 5 byte
• Ma in questo caso, „,;Çcon 4 byte sarebbe l'opzione migliore (punti di codice dei caratteri ',' e ';')

[2,4,6,0]( utilizzato in questa risposta di @Emigna ):

• •3ā•7в è di 6 byte (generato dal generatore dell'elenco di numeri interi compressi)
• Ž3ā7в è di 5 byte
• Ma in questo caso, Ž9¦Scon 4 byte sarebbe l'opzione migliore (intero compresso 2460 in un elenco di cifre)

10101001100101001( usato in questa mia risposta ):

• •a½₄Ƶ6®í• è 9 byte (generato dal generatore intero grande compresso)
• •1∊}•2вJ è 8 byte (generato dal generatore di elenco di numeri interi compressi con join aggiunto)
• Ma in questo caso •1∊}•bcon 6 byte sarebbe l'opzione migliore (elenco intero compresso, con un al binario invece di 2в, che si unisce implicitamente)

[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]( usato in questa mia risposta ):

• •4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в è 57 byte (generato dal generatore di elenco di numeri interi compressi)
• •6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-øJδŠ₂ + Öηôî®À8 † 6 / ðÎ6ùøΓ ° ÓĆ; ˆ © Ā • 2ô` è anche 57 byte (intero compresso, diviso in parti della dimensione 2)
• •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ ,λ₂ϦP(Ì•65в₂+è tuttavia più breve di 2 byte, comprimendo l'elenco con ciascun valore 26 inferiore, quindi aggiungendolo successivamente con `₂ + ` . Questo trucco per aggiungere un valore a byte singolo in seguito può essere usato abbastanza spesso per salvare byte in elenchi compressi.

Input implicito

Ai tempi in cui era stato rilasciato 05AB1E, l'input implicito era abbastanza nuovo e sofisticato. Oggi sembra essere necessario per tenere traccia di altri linguaggi competitivi (come Jelly, MATL, Pyth, ecc.).

Ad esempio, quando vuoi aggiungere due numeri, puoi fare II+:

I    # Input_1.
 I   # Input_2.
  +  # Add them up.

Provalo qui

Tuttavia, usando l' input implicito , possiamo accorciare solo a 1 byte, vale a dire +:

+    # Take two numbers implicitly and add them up.

Provalo qui

Ciò accade solo quando la lunghezza della pila è inferiore all'arità dell'operatore. Un ultimo esempio è 3+. L'arità +dell'operatore è 2 mentre nello stack è presente solo 1 elemento:

3    # Push the number 3 on top of the stack.
 +   # Request implicit input and add to the 3.

Provalo qui

sottostringhe

£è il comando per prendere i primi bcaratteri della stringa a.
ex: "hello_world"5£ -> "hello"

Ma se bè un elenco di indici, invece divide la stringa in parti di (fino a) quelle dimensioni.
ex: "hello_world"5L£ -> ['h', 'el', 'lo_', 'worl', 'd']

Variabili predefinite

Sono un po 'nascosti in 05AB1E. Ecco un elenco di tutte le variabili predefinite:

• ¾, invia 0se la counter_variable non viene modificata prima di questo comando.
• X, invia 1se la variabile X non viene modificata prima di questo comando con U.
• Y, invia 2se la variabile Y non viene modificata prima di questo comando con V.
• ®, invia -1se il registro non è stato modificato prima di questo comando con ©.
• ¯, invia [](array vuoto) se non viene aggiunto nulla a global_array prima di questo comando.
• ¸, [""]inserisce uno stack vuoto se non è presente alcun input. (Grazie @Emigna per aver trovato questo.)

Usare la tela ( Λo .Λ)

Dato che non faceva parte dei documenti e @Adnan è attualmente un po 'troppo impegnato per scriverlo, ho chiesto il permesso di aggiungerlo come suggerimento qui per ora.

La funzione Canvas ( Λo .Λ) può essere utilizzata per disegnare linee ASCII sullo schermo. Ha tre parametri richiesti:

• a Lunghezza: la dimensione delle linee. Questo può essere un singolo numero intero o un elenco di numeri interi
• b Stringa: i caratteri che vogliamo visualizzare. Può trattarsi di un singolo carattere, una stringa, un elenco di caratteri o un elenco di stringhe (negli ultimi tre casi li utilizzerà tutti uno a uno, incluso il wrapping)
• c Direzione: la direzione in cui devono essere tracciate le linee del carattere. In generale abbiamo le cifre[0,7]per le direzioni, per le quali possiamo usare una o più. Ci sono anche alcune opzioni speciali che richiedono un certo personaggio (ne parleremo più avanti).

Le cifre delle direzioni vengono associate [0,7]alle seguenti indicazioni:

7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

Alcuni esempi 05AB1E rispondono all'utilizzo del Canvas:

• Stampa un negativo del tuo codice
• Ottagoni d'arte ASCII
• Torre Eiffel: crea una grande "A" da "A" s
• Crea un riflettore alfabetico!
• Una spirale ASCII ben spaziata

Facciamo qualcosa di simile a quello precedente, quindi supponiamo di usare la Λfunzione Canvas con i seguenti tre parametri:

• a :[3,3,5,5,7,7,9,9]
• b :!@#
• c :[0,2,4,6]

Questo darà il seguente output:

  !@#!@#!
  #     @
  @ #!@ #
  ! @ # !
  # ! ! @
  @   @ #
  !#@!# !
        @
@!#@!#@!#

Provalo online.

Quindi, come funziona? Bene, ecco i passaggi con questi input sopra:

1. Disegna i 3caratteri ( !@#) verso l'alto (direzione 0)
2. Disegna i 3-1caratteri ( !@) verso destra (direzione 2)
3. Disegna 5-1caratteri ( #!@#) verso il basso (direzione 4)
4. Disegna i 5-1caratteri ( !@#!) verso sinistra (direzione 6)
5. Disegna i 7-1caratteri ( @#!@#!) verso l'alto (direzione 0)
6. Disegna i 7-1caratteri ( @#!@#!) verso destra (direzione 2)
7. Disegna 9-1caratteri ( @#!@#!@#) verso il basso (direzione 4)
8. Disegna i 9-1caratteri ( !@#!@#!@) verso sinistra (direzione 6)

Il -1ci sono perché le linee si sovrappongono. Quindi i primi due passaggi sono:

#
@
!

E

 !@

Che combinato è:

#!@
@
!

Alcune note minori:

• Oltre alle opzioni [0,7]ci sono alcune opzioni specifiche disponibili, che sostanzialmente si traducono in una certa sequenza di direzione.
  • +(in '+linea) si traduce nel modello 04402662, che crea un +incrocio con le braccia della lunghezza data. Guardalo in azione.
  • ×(in '×linea) si traduce nel modello 15513773, che crea un Xincrocio con le braccia della lunghezza data. Guardalo in azione.
  • 8ritorna all'origine da cui abbiamo iniziato a disegnare. Guardalo in azione e vedi la differenza senza il8 .
• L'integrato Canvas aggiungerà implicitamente spazi finali per rendere l'output un rettangolo.
• L' Λoutput verrà immediatamente emesso e .Λrisulta una stringa che viene inserita nello stack, che possiamo ancora riutilizzare, modificare e fare qualsiasi cosa che vorremmo. Qualche esempio:
  • Possiamo convertirlo in un elenco di stringhe o in un elenco di caratteri .
  • Potremmo sostituire un certo personaggio
  • Inserisci un certo carattere
  • ecc ecc.

Pop o get

Come in altri linguaggi basati su stack, le funzioni di 05AB1E di solito pop (consumano) i loro input dallo stack e spingono i loro output sullo stack.

Tuttavia, alcune funzioni ottengono i loro input dallo stack senza consumarli. Un esempio è la headfunzione, ¬che produce il primo elemento dall'elenco di input. Vedere un esempio di programma qui: ¬+. Ciò aggiunge il primo numero dell'elenco di input a ciascun numero di tale elenco.

Per sapere quali funzioni pop e quali ottengono, vedere la colonna corrispondente nel file di informazioni sulla funzione .

Condizionali e anelli

I loop e i condizionali ricevono automaticamente parentesi di chiusura alla fine di un programma, quindi è necessario aggiungerli nel codice solo se è necessario qualcosa al di fuori del ciclo / condizionale.

Ad esempio, questo programma (non salvato) che crea un elenco dei nprimi numeri primi non richiede parentesi di chiusura. [¹¾Q#NpiNˆ¼

Ma se volessimo eseguire alcune operazioni sull'elenco risultante, ad esempio prendendo delta dovremmo prima chiudere il ciclo. [¹¾Q#NpiNˆ¼]¯¥

Piccoli suggerimenti per il golf 05AB1E

Espanderò questo con piccoli suggerimenti sul golf che ho imparato lungo la strada. (Ho appena avviato 05AB1E personalmente.)

• D(duplicato) e Ð(triplicato) in combinazione con s(swap) e Š(triple-swap a,b,cto c,a,b) sono generalmente più brevi rispetto all'utilizzo ©(save in global_variable ) e ®(push global_variable ) all'interno dei loop. Ciò ha salvato un byte in questa mia risposta , così come due in questa mia risposta .
• ½(se 1, quindi aumentare counter_variable di 1) non è necessario alla fine di a µ(mentre counter_variable ! = a, do ...), dal momento che è fatto implicitamente ( salvato un byte in questa mia risposta ).
• .Bsi divide implicitamente su nuove righe. Questo è stato utile in questa mia risposta quando cercavamo un'alternativa per ¡(dividere) mantenendo comunque gli oggetti vuoti (NOTA: la soluzione nella risposta collegata non funziona quando gli elementi contengono spazi finali dopo la divisione.) - Speriamo che un builtin essere aggiunto per dividere ma mantenere righe vuote in futuro.
• SÖ(quale delle cifre dell'intero input può dividere uniformemente l'input intero) conterrà il numero stesso per le cifre 0(anziché errori di divisione per zero). Ad esempio, 1053comporterà[1,1053,0,1] (1053 è divisibile per 1 e 3; non è divisibile per 5; e dà un errore di divisione per zero per 0). Questo è stato piuttosto utile in questa mia risposta prendendo il potere della lista, poiché solo in 105AB1E è vero e tutto il resto è falso. SÖPrisultante in verità ( 1) significa quindi che un intero di input è uniformemente divisibile per ciascuna delle sue cifre.
• Dopo aver visto û(palindromizzare una determinata stringa) sono rimasto sorpreso che non sia incorporato un is_palindrome . Ma più tardi ho realizzato che sono necessari solo 2 byte per ottenere ciò, che sono ÂQ(dov'è Âbiforcato, che è l'abbreviazione di DR: copia duplicata e inversa; Qè per verificare se i due valori principali nello stack sono uguali).
• Quando vuoi filtrare un elenco per più cose, di solito è più economico avere più filtri sciolti piuttosto che tutti combinati in uno. Perché quando hai due filtri avrai bisogno di qualcosa di simile a Ds*(duplica, scambia, moltiplica per agire come AND-logico) vs }ʒ(chiudi il primo filtro, filtra di nuovo) quando usi due filtri. Ad esempio: in questa sfida dobbiamo elencare tutti i numeri di quattro cifre lunghe, contenenti almeno una 0e con una somma di cifre pari a 9. L'uso di un intervallo [1000,10000]copre il numero di quattro cifre lunghe, ma poi ti rimangono altri due filtri. Inizialmente ho usato ₄4°ŸʒD0åsSO9Q*(14 byte), ma usando due filtri è possibile salvare un byte: ₄4°Ÿʒ0å}ʒSO9Q(13 byte). (Che in seguito è stato portato a ₄4°ŸεW°ö9Q(10 byte) da @Grimy.)
• Quando si desidera comprimere con intero 0come riempimento, è possibile utilizzare 0ζ. Un problema con questo, tuttavia, è che il filler 0diventerà una stringa "0", quindi se in seguito si tenta di ordinare con stringhe miste e numero intero, molto probabilmente questo non darà il risultato desiderato. Ecco un esempio di come andrà a ordinare le liste interne con zip: 0ζ€{. Questo può essere risolto con l'aggiunta di un cast esplicito a int ( ï) dopo la zip, e solo allora scegli: 0ζï€{. Tuttavia, usando la ¾costante as 0con lo zip-filler, rimarrà un numero intero anziché una stringa durante lo zip. Quindi ¾ζ€{salverà un byte qui. Questo suggerimento è stato fornito da @ Mr.Xcoder per salvare un byte in questa mia risposta .
• Se si desidera sommare le cifre di più numeri in un elenco, è possibile utilizzare €SO. Tuttavia è più breve l'utilizzo 1ö, che vettorializza automaticamente. Questo suggerimento è stato fornito da @Grimy per salvare un byte qui (e 2 byte qui ).
• Se hai a che fare solo con numeri interi non negativi e vuoi controllare all'interno di un filtro se è 0 o 1, puoi ovviamente usare l'ovvio 2‹. Tuttavia, l'uso di !(fattoriale) comporterà solo 1 (verità) per 0e 1, e ogni altro valore comporterà qualcosa di più elevato (e quindi falso, poiché solo in 105AB1E è vero). Questo suggerimento è stato fornito da @Grimy per salvare un byte qui .

Vettorializzazione automatica

Si noti che alcuni operatori in 05AB1E vettorizzano automaticamente su array. Ad esempio, il codice 5L3+, che disassembla al seguente pseudocodice:

[1, 2, 3, 4, 5] + 3

potrebbe diventare:

[4, 5, 6, 7, 8]

Se non vettorializza automaticamente, puoi anche usare l' €operatore. Prende un comando a carattere singolo ed esegue quell'operatore (monadico) su ciascun elemento. Un esempio per dividere ogni elemento è il seguente codice ( provalo qui ):

€S

Considerando che l' Soperatore normale dividerebbe ogni elemento nell'array e lo appiattisce in un singolo array ( provalo qui ).

Ordinamento degli ingressi

L'ordine in cui prendi l'input può avere un effetto drastico sul tuo codice e, spesso se stai usando sper scambiare la parte superiore dello stack con la cosa successiva più alta nello stack, non stai pensando al problema correttamente. Prova a riordinare gli input e vedi se riesci a liberarti della necessità di scambiare scambiando gli input in anticipo, aggiungendoli allo stack in precedenza o duplicandoli da qualche parte. L'I & O più ovvio può essere la risposta 05AB1E di minor successo.

05AB1E ASCII-Art Golfing

Il codice seguente aiuta a trasformare ASCII-art in 05AB1E usando una conversione di base personalizzata.

|»©ÐÙSDŠ¢øΣθ}R€н¬®sÅ?iD2£RDŠKsì}J©žLR‡®gö₅B®s"•ÿ•“ÿ“ÅвJ"

Provalo online.

Questo è realizzato da:

1. Elencando i caratteri univoci nel disegno ASCII.
2. Ordinali per quante volte si verificano nella stringa in ordine decrescente (dalla maggior parte dei caratteri meno ricorrenti).
3. Invertire i primi due elementi se il disegno ASCII inizia con il carattere più ricorrente (per evitare 0 iniziali nell'intero compresso).
4. Mappare i caratteri dell'input 0-9A-Za-zin quell'ordine, ogni carattere distinto ottiene il proprio carattere di mappatura, fino a quando ognuno non è stato sostituito.
5. Base comprimilo, usando la base più alta che devi sostituire (in base alla quantità di caratteri univoci).
6. Base lo converte di nuovo in base-255 (per la compressione 05AB1E).
7. Format tutto nel formato: •<compressed_integer>•“<sorted_distinct_characters>“ÅвJ.

Ciò “consente di comprimere anche le virgolette "; la Åвuserà questa stringa di base-convertire l'intero generato utilizzando la stringa come base personalizzato; e Junirà tutti questi caratteri in un'unica stringa, che viene prodotta implicitamente.

Accetta modelli con fino a 62 caratteri unici inclusi, ottimo per l'arte ASCII.
Minore è la quantità di caratteri unici, migliore è la compressione.

Esempio di output per disegnare il diagramma temporale digitale XNOR (214 byte, 9 caratteri univoci):

    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐  
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐   
X ──┘     └───┘ └───┘ └───┘   └────

Sarebbe:

05AB1E , 106 byte

•I£.µ*:]ó±øqaµb₄ΘYQmœ¹µû₄p´ζÂĆ_5ŠKÑ×ðòË|₄#¹¶úôÂ-Í|¯ε¼É₂ïδ&é–9»ÞFò1î×HÃBjý2ĆÉ≠FYÂÂèC j‘£Å₅Œ•“─ └┘┐┌
XBA“ÅвJ

Provalo online.

(106/214) * 100 = 49,53% la dimensione della stringa originale ASCII-art.

Che è lo stesso numero di byte della mia richiesta effettiva per quella sfida in 05AB1E (legacy).

Spiegazione del codice:

NOTA: il codice non è assolutamente golfato. È rapidamente scritto per convertire l'arte ASCII nella compressione più efficiente, quindi è piuttosto brutto e lungo ..

|»               # Take multi-line input
  ©              # Store it in the register to reuse later                         
ÐÙS              # Only leave unique characters (as list)
   DŠ¢ø          # Map it with the count for each of those characters
       Σθ}R      # Sort it based on that count (highest to lowest)
           €н    # Remove the count again, so the sorted characters remain
¬®sÅ?i           # If the input starts with the most occurring character:
      D2£RDŠKsì} #  Swap the first two characters in the list
J©               # Join everything together, and store it in the register to reuse later
  žLR‡           # Map each character to [0-9A-Za-z]
      ®gö        # Get the amount of unique characters, and convert it to that Base
         ₅B      # And then convert that to Base-255
®s               # Push the string and swap so the compressed integer is at the top again
  "•ÿ•“ÿ“ÅвJ"    # Insert it in the correct output format
                 #  `•<compressed_integer>•“<sorted_distinct_characters>“ÅвJ`
"•ÿ•"            # (after which the result is output implicitly with trailing newline)

Stringhe e ints sono tipi uguali

Non qualcosa con cui tutti sono d'accordo, ma funziona.

Considera i due programmi seguenti:

4 5+
"4""5"+

Entrambi risultano in 9 . Questo perché ogni valore viene prima valutato (con ast.literal_eval). Per questo motivo, possiamo eseguire tutti gli operatori di manipolazione delle stringhe su ints e tutti gli operatori di manipolazione int sulle stringhe.

Ad esempio, 12345ûpalindromizza il numero 12345, risultando in 123454321. Dopodiché, possiamo fare la matematica normale su questo numero.

12345û50000-

Ciò si tradurrebbe in: 123404321 .

Loop e iteratori nascosti

05AB1E ha i seguenti loop e iteratori normali:

• F, che scorre tra 0 .. n-1 .
• G, che scorre tra 1 .. n-1 .
• ƒ, che scorre tra 0 .. n .
• v, che scorre su ogni elemento s [0], s [1], .., s [n] .
• ʒ, che non è esattamente un ciclo, ma un comando di filtro . Abusiamo di questo comando per il suo comportamento involontario di loop attraverso ogni elemento.

Usando questi loop, possiamo derivare i seguenti loop nascosti :

• Invece di gF, puoi usare quello vche ha anche un N-index che può essere usato.
• La vy -> ʒsostituzione è un po 'più complicata:
  • Devi stampare immediatamente i risultati. Ciò sorprende la stampa automatica dalla stampa della parte superiore della pila.
  • Lo snippet di codice viene eseguito su un nuovo stack temporaneo . Ciò significa che non è possibile utilizzare snippet dipendenti dallo stack.
  • yIn questo tipo di loop non è possibile invocare .