Ora che sono completamente dipendente da Code Golf, probabilmente è giunto il momento che provo a prendere alcune lingue da golf.

Dato che gioco quasi esclusivamente in JavaScript, Japt sembra il linguaggio logico per cominciare. Mi immergerò nella documentazione alla prossima occasione che avrò ma, nel frattempo, per favore pubblica tutti i suggerimenti che hai per Japt nelle risposte qui sotto.

Dato che sono un principiante nelle lingue di Japt e del golf in generale, se potessi "tradurre" i tuoi suggerimenti in JavaScript, ove possibile, ciò sarebbe di grande aiuto per aiutarmi ad affrontare le cose.

Passando da JavaScript a Japt

Come forse saprai, Japt è semplicemente una versione ridotta ed estesa di JavaScript. Ho creato Japt perché ero stanco di nomi di proprietà lunghi, like String.fromCharCode(x)e Math.floor(x), e della noiosità di fare cose come la creazione di un intervallo. Ecco il minimo indispensabile che devi sapere quando passi da JavaScript a Japt:

• Japt è una lingua tradotta ; Il codice Japt viene convertito in JavaScript e quindi eseguito come JS. (Immagino che potresti dire compilato , ma traspilato suona più hipster. Disclaimer: non so assolutamente nulla dell'essere hipster)
• Tutte le voci sono programmi completi per impostazione predefinita. L'ingresso è implicitamente analizzato, e le prime sei ingressi sono messi in variabili U, V, W, X, Y, e Z; l'array completo è archiviato in N. Il risultato dell'ultima espressione viene stampato automaticamente.
• Tutte le lettere maiuscole sono variabili e rimangono invariate quando traspilate. La maggior parte ha valori preimpostati, che puoi trovare nella sezione "Variabili" dei documenti Japt ( nell'interprete ).
• Tutte le lettere minuscole sono funzioni o metodi prototipo . Japt aggiunge i metodi a- z(e à- ÿ) su numeri, stringhe e matrici. Quando usi una di queste lettere, Japt compila il .e (; Ucin Japt è equivalente a U.c(JavaScript, che potrebbe significare ceil, charCodeAt o concat, a seconda del tipo di U. Questo è da dove proviene la maggior parte del potere di Japt; puoi trovare un elenco completo di questi metodi nelle sezioni "_____ funzioni" dei documenti Japt ( nell'interprete ).
• Uno spazio rappresenta )e )rappresenta )). Questo perché quando ho progettato Japt per la prima volta, volevo salvare il maggior numero di byte possibile, ed è così che ho pensato di farlo. (Anche Us w nse sembra migliore di Us)w)n), IMHO.)
• Una funzione è indicata come ABC{...}, dove ABCpuò essere qualsiasi stringa di variabili. Le funzioni funzionano per la maggior parte come in JS, la differenza principale è che viene automaticamente restituita l'ultima espressione (piuttosto che dover usare returno utilizzare parentesi ES6).
• 'denota una singola stringa di caratteri (cioè 'aè uguale a "a") e #prende il successivo codice di caratteri e diventa quel numero ( #eè lo stesso di 101).
• Qualunque cosa tra i simboli del dollaro $rimane la stessa durante il processo di transpilation. Puoi usarlo per implementare i forloop, ad esempio, dato che Japt non ha quelli, ma suggerirei di usare altri metodi (comem su stringhe e array o osui numeri).
• La maggior parte degli altri caratteri comunemente utilizzati in JS - "", 0-9, (, +, =, ecc - rimanere lo stesso quando transpiled (per la maggior parte, comunque).

E questo è tutto ciò che devi sapere per scrivere il codice Japt di base. Raggiungere la massima potenza di golf in Japt richiede maggiori conoscenze, ma ciò può essere trovato in altre risposte.

Ecco un esempio di base. Supponi di voler prendere una stringa di caratteri ASCII e sostituirli con il suo codice char esadecimale. Ecco come potresti farlo in JavaScript:

U.split("").map(x=>x.charCodeAt(0).toString(16)).join("")

Ora per convertire a Japt. .split("")in JS equivale a q""in Japt, o anche più breve, giusto q. .join("")è anche giusto q, la differenza è che l'oggetto è un array anziché una stringa. .map(è m, .charCodeAt(è ced .toString(è s. Quindi il nostro codice Japt potrebbe apparire come:

Uq mX{Xc0 s16} q 

In Japt, tuttavia, mfunziona anche sulle stringhe come sugli array, quindi possiamo rimuovere entrambi q:

UmX{Xc0 s16}

Provalo online! Come puoi vedere nella casella "Codice JS", questo si traspone direttamente a:

U.m(function(X){return X.c(0).s(16)})

Man mano che impari a lavorare con Japt, sarai sempre meno focalizzato sulla conversione avanti e indietro da JavaScript e sarai in grado di codificare in Japt come lingua propria. Ecco una spiegazione tralasciando completamente la parte JavaScript:

UmX{Xc0 s16}
               // Implicit: U = input string
UmX{       }   // Take U, and replace each character X with the result of this function:
    Xc0        //   Take the char-code at index 0 in X (the first and only one).
        s16    //   Convert this to a hexadecimal string.
               // Implicit: output result of last expression

Compressione di array di stringhe

AGGIORNAMENTO: Da allora gli strumenti presenti in questo suggerimento sono stati riscritti, migliorati e integrati nel mio interprete Japt . Per i migliori risultati si consiglia di utilizzare quel compressore su uno di quelli collegati di seguito. Rivisiterò questo suggerimento quando avrò ancora un po 'di tempo e lo riscriverò pensando al nuovo compressore.

introduzione

Se hai una matrice di stringhe nel tuo codice, il modo più ovvio per comprimerlo sarebbe quello di eseguire ciascuna stringaOc singolarmente. Ai fini di questo suggerimento, lavoreremo con l'array ["lollipop","marshmallow","nougat","oreo"], che inizialmente ha un peso di 42 byte. L'esecuzione di ogni stringa Occi dà:

[`lo¥ipop`,`Ú\hÚaow`,`Í`,`eo`]

Adesso sono 33 byte, un risparmio decente.

Passo 1

Ma possiamo fare di meglio. Se uniamo l'array a una stringa separata newline, possiamo eliminare parentesi, virgole e backtick estranei e dividere su newline per ottenere il nostro array. Applicandolo al nostro array di esempio ci viene fornito quanto segue:

`lo¥ipop
Ú\hÚaow
Í
eo`·

Fino a 26 byte ora.

Passo 2

Ma possiamo fare ancora meglio! Potremmo usare una lettera minuscola per delimitare le stringhe anziché una nuova riga, che potrebbe essere inclusa nella compressione. znon viene utilizzato in nessuna delle nostre stringhe, quindi inseriamolo e vediamo come andiamo avanti.

`lo¥ipopzÚ\hÚaowzÍzeo`qz

Ah, noccioline - nessun miglioramento lì; il nostro numero di byte è aumentato di uno! Ci potrebbe essere un'altra lettera si potrebbe usare, ma, a seconda delle vostre corde, ci potrebbe essere un bel po 'per provare - nel nostro esempio ci sono 11: b,c,d,f,j,k,q,v,x,y,z. Provare ciascuno sarebbe piuttosto noioso, ed è qui che entra in gioco questo pratico strumento ; dategli le vostre stringhe separate di nuova riga e proverà a delimitare le stringhe con ogni lettera che non è contenuta in nessuna di esse e l'output:

• la stringa compressa più corta,
• il delimitatore che utilizza e
• la sua lunghezza.

L'esecuzione delle stringhe di esempio attraverso di essa mostra che boffre i migliori risultati:

`lo¥ipáæqrÚaowbÍÞo`qb

E il gioco è fatto, siamo a soli 24 byte.

Passaggio 3

Ma possiamo fare ancora meglio! Se l'ordine delle stringhe nel tuo array non ha importanza, forse c'è una permutazione diversa combinata con un delimitatore diverso che potrebbe funzionare ancora più breve. Tuttavia, provare ogni possibilità sarà molto più noioso. Con le nostre 4 corde, ci sono 24 diverse permutazioni da provare. Con ognuna delle 11 possibili lettere che diventano 264! È qui che entra in gioco questo strumento . Ancora una volta, alimentalo con le tue stringhe separate di nuova riga e proverà ogni combinazione di ogni permutazione e ogni lettera di delimitazione, producendo:

• l'ordine delle stringhe nella stringa compressa più corta,
• la stringa compressa,
• il delimitatore che utilizza e
• la sua lunghezza.

L'esecuzione delle stringhe di esempio attraverso di essa mostra che "nougat","oreo","lollipop","marshmallow"con bcome delimitatore si ottengono i risultati migliori, con un conteggio finale di byte di soli 23:

`ÍÞo½o¥ipáæqrÚaow`qb

Suggerimento bonus: Compressione array intero

È possibile applicare lo stesso principio alle matrici di numeri interi convertendoli prima in una base superiore. Utilizzando questo esempio, array di 36 byte:

[588181,156859,595676,475330,680474]

Possiamo ottenere questo fino a 29 byte convertendolo prima in un array di stringhe di base 32 e quindi eseguendolo attraverso il primo programma di compressione:

`huclt4p5r5ÛÊg62tkogq`qt mnH

O a partire da 27 byte usando il secondo programma:

`4p5Ïcl5ÛÊg62tkogq`qt mnH

Potresti essere in grado di salvare un altro byte o 2 in più spostando la conversione di numeri interi in un metodo che stai già eseguendo sull'array.

Appunti

1. Non dimenticare di tenere conto dei q<letter>(<space>)costi di 1 o 2 byte extra ·. Tuttavia, potresti essere in grado di utilizzare una delle scorciatoie Unicode per recuperare un byte, a seconda del delimitatore ( qÊè lo stesso ql<space>, ad esempio).
2. Un avvertimento quando si utilizza l'ultimo strumento: più stringhe si hanno, più permutazioni ci saranno e più lento verrà eseguito il programma, fino a quando non si esaurisce. Come spiegato sopra, con le nostre 4 stringhe di esempio e 11 possibili lettere da provare, ci sono 264 combinazioni possibili, aumentare il numero di stringhe di solo 1 con le stesse 11 lettere e abbiamo già 1320 combinazioni da provare. (È possibile utilizzare questo strumento per contare il numero di combinazioni, se lo si desidera).

Titoli di coda

• Oliver per l'ispirazione per creare gli strumenti trovati in questo suggerimento.
• ETHproductions per la correzione di bozze.

Comprimere le stringhe

Japt (attualmente) utilizza la libreria shoco per la compressione delle stringhe. Puoi comprimere una stringa arbitraria usando Oc, purché contenga esecuzioni di lettere minuscole:

Oc"Hello, World!"

Questo produce HÁM, WŽld! (beh, Žtecnicamente è un carattere non stampabile). Puoi decomprimerlo avvolgendolo in backtick:

`HÁM, WŽld!`

Provalo online!

In alternativa, è possibile utilizzare la Odfunzione per decomprimere una stringa arbitraria. Questo di solito non è utile, ma ha i suoi scopi ...

Accorciamento dei numeri con codici a caratteri

In Japt, puoi usare # , seguito da un carattere per creare un codice char. Questo è utile quando si accorciano numeri più lunghi.

Come menzionato da @ETHproductions, questo funziona solo su corse a tre cifre nell'intervallo 100-255, a meno che tu non sia disposto a passare a UTF-8.

Esempi:

123 può essere abbreviato in #{

101 può essere abbreviato in #e

Puoi anche unirli insieme:

123101 può essere abbreviato in #{#e

È possibile utilizzare String.fromCharCode(123)in JavaScript o 123din Japt per trovare il carattere appropriato.

String.fromCharCode(123) ritorna {

Suggerimento rapido: array vuoto []

Japt ha una costante per un array vuoto: A. Ma, per accedervi, è necessario anteporre un punto ;e virgola al programma per utilizzare le costanti alternative di Japt, altrimenti Alo sarà 10. Quindi l'utilizzo in ;Arealtà offre un risparmio di 0 byte [], ma ti farà risparmiare byte se devi assegnare l'array a una variabile (ad es A=[].).

Tuttavia, se (e solo se) il tuo programma non sta prendendo alcun input, puoi accedere all'array vuoto con solo 1 byte usando la Nvariabile, che è l'array di input - senza input, sarebbe vuoto. Provalo qui .

Ciò ha anche l'ulteriore vantaggio di consentire all'utente di utilizzare i valori delle costanti predefinite nel programma e, in alcuni casi, può comunque risparmiare byte sull'uso ;Aanche quando il programma sta inserendo input grazie alle scorciatoie per s1e s2.

Valutazione di JavaScript

Japt ti consente di eseguire JavaScript non elaborato racchiudendolo $...$.

Per esempio, $alert("hello world")$

Questo può essere abbreviato sfruttando la chiusura automatica di Japt $e ).

$alert("hello world")$ può essere abbreviato in $alert("hello world"

Compressione di JavaScript

Puoi anche comprimere JavaScript usando Ox.

Se c'è una funzione JavaScript che vuoi usare, diciamo screen.width, puoi comprimere la stringa "screen.width"usandoOc , quindi inserendo il risultato tra Ox` ... `

Si noti che non è necessario chiudere le virgolette in Japt quando non è seguito da nient'altro.

Conosci le bandiere

Secondo l'ultimo meta consenso (dicembre 2017) , i flag della riga di comando non vengono più conteggiati verso i byte. È davvero una grande notizia per Japt poiché ha molte bandiere per un trattamento extra su input / output.

Tutte le bandiere disponibili in Japt sono descritte di seguito, nell'ordine di valutazione . Le bandiere nello stesso gruppo sono esclusive tra loro. Si noti che le bandiere in diversi gruppi possono essere utilizzati in combinazione, con conseguente qualcosa come questo :)

mdefæ

L'intero programma è mappato sul primo argomento ( U).

Se sono presenti più argomenti, vengono passati così come sono (ovvero non mappati in modo accoppiato). Altrimenti, il secondo argomento è l'indice e il terzo è l'intero array, proprio come U.m. Se Uè un numero, viene convertito in intervallo; se stringa, viene convertito in array di caratteri e i risultati vengono uniti.

• -m: Applica quanto sopra e nient'altro.
• -d: Restituisce truese un risultato è veritiero, falsealtrimenti.
• -e: Restituisce truese tutti i risultati sono veritieri, falsealtrimenti.
• -f: Restituisce la matrice di elementi i Ucui risultati sono veritieri.
• -æ: Applica -fe restituisce il suo primo elemento.

gh

Prende un elemento nell'indice specificato.

• -g: Accetta il primo elemento (indice 0).
• -gX: Prende l'elemento all'indice X(può essere qualsiasi numero intero positivo).
• -h: Prende l'ultimo elemento.

!¡

Converti il ​​risultato in booleano.

• -!: Non applicare booleano.
• -¡: Applica booleano non due volte (restituisce la verità).

N

Converti il ​​risultato in numero. Viene utilizzato il plus unario.

PRSQ

Converti in una stringa di qualche tipo.

• -P: Unisciti alla matrice con "".
• -R: Unisciti alla matrice con "\n".
• -S: Unisciti alla matrice con " ".
• -Q: Applica JSON.stringify(può essere qualsiasi oggetto, non solo un array). Esempio .

x

Applica la funzione xall'output. (È letteralmente x, non "nessuna singola funzione alfabetica minuscola".)

• Matrice: Somma.
• String: Trim da entrambe le estremità.
• Numero: da rotondo a intero.

Scorciatoie Unicode

Ci sono molte strutture comuni in Japt che proprio non può essere memorizzati in un singolo carattere ASCII, come qS , p2 , mX{, } , ecc Quindi per aggirare questo, Japt ha "scorciatoie Unicode", che sono caratteri nell'intervallo \xA1- \xDE( ¡- Þ) che si espandono a queste strutture comuni. Puoi trovare un elenco completo di questi nel documenti dell'interprete .

Inoltre, @sta per XYZ{, e _sta per Z{Z, per le funzioni di aiuto di compilazione. Quindi, golf il nostro programma di esempio da un'altra risposta :

UmX{Xc0 s16}

In primo luogo, possiamo sostituire X{Xcon _, che ci dà:

Um_c0 s16}

Quindi possiamo sostituire m_con il ®salvataggio di un altro byte:

U®c0 s16}

Oppure potremmo sostituirlo X{con @, il che ci dà:

Um@Xc0 s16}

Questo ci consente quindi di utilizzare il ¡collegamento per salvare due byte:

¡Xc0 s16}

Uno di questi due percorsi può essere ridotto di 1 byte in più rispetto all'altro. Riesci a capire quale?

Approfitta delle variabili preimpostate

Variabili A: Ssono preimpostate su valori comuni che richiedono più di un byte per rappresentare in Japt:

• A- Gsono 10- 16.
• Hè 32, Iè 64, Jè -1, Lè 100.
• Kè definito come new Date(), che puoi manipolare in vari modi.
• Me Osono oggetti con varie utili funzioni. Puoi saperne di più nei documenti.
• Pè la stringa vuota, Qè una virgoletta, Rè una nuova riga ed Sè uno spazio.
• Tè impostato su 0, quindi è possibile utilizzarlo come accumulatore, se necessario.

Se il primo carattere nel programma è un punto e virgola ; e , A-Lvengono ripristinati come segue:

• Aè l'array vuoto [].
• Blo è "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
• C è "abcdefghijklmnopqrstuvwxyz".
• D è "QWERTYUIOP\nASDFGHJKL\nZXCVBNM".
• Eè "[a-z]"eF è "[A-Za-z]"(utile prima che li aggiungessi come funzionalità regex)
• Gè 36, Hè 65ed Iè91 (utile per gli intervalli alfabetici).
• J è una virgola singola; L, un solo periodo.

Al giorno d'oggi solo A, B, C, e Dda questa lista sono veramente utili. Sto programmando di aggiungere un sistema migliore che consenta fino a 256 variabili a due byte, che saranno preimpostate su questi valori e molto altro ancora.

Usa le funzioni automatiche

Molto probabilmente lo sapete già @e _sono scorciatoie per XYZ{e Z{Z, rispettivamente (coperte nelle scorciatoie Unicode risposta delle ). Ma a volte puoi rendere le funzioni ancora più brevi.

Supponiamo di avere una serie di caratteri e di voler mappare ciascun personaggio al suo codice di caratteri. Puoi farlo con uno di questi:

mX{Xc} 
m_c} 

Ma c'è un modo migliore. Se un metodo o un operatore è il primo elemento dopo un altro metodo o un (, viene trasformato in una stringa. Quindi queste due linee sono equivalenti:

r'a'b  // Replace all "a"s with "b"s; transpiles to .r("a","b")
ra'b   // Does the same thing, 1 byte less; transpiles to the same thing

Ma come può aiutarci con le nostre funzioni? Bene, la maggior parte dei metodi che accettano funzioni, se viene data una stringa che rappresenta un metodo o un operatore, la interpreterà come una funzione. Ciò significa che puoi anche fare questo:

m_c}  // Map each item to its char code
m'c   // Does the same thing, 1 byte less
mc    // Also does the same thing, 2 bytes less

Chiamo queste "funzioni automatiche". Esistono diverse varietà:

• m@Xc} → mc
• m@Xc1} → mc1
• m@X+1} → m+1
• m@1+X} → m!+1
• m@2pX} → m!p2

Spero che tu abbia l'idea. Per scambiare gli argomenti, basta aggiungere il prefisso al metodo o all'operatore !.

Assegnazione variabile implicita

Ogni volta che si avvia una nuova riga in Japt, il risultato della riga precedente viene automaticamente assegnato a una delle variabili di input ( U- Z), con la prima riga che è U, la secondaV e così via.

Facciamo un esempio: supponiamo che tu voglia creare 2 array con cui lavorare, uno contenente i numeri 1-10 e l'altro contenente i loro quadrati. La lunga strada da fare sarebbe così:

U=Aõ V=Um² [do something with the arrays]

Utilizzando l'assegnazione variabile automatica, tuttavia, che può essere abbreviata in:

Aõ
Um²
[do something with the arrays]

Abbiamo salvato 4 byte lì. Ma, in questo caso, possiamo salvare un altro byte perché l'array di 1-10 è assegnato Ue Upuò essere omesso in alcuni scenari :

Aõ
m²
[do something with the arrays]

Attenzione

Una cosa a cui prestare attenzione con questo suggerimento è che non si sovrascrive alcuna variabile di input che potrebbe essere necessaria in seguito nel programma. Questo può essere evitato lasciando una o più righe vuote all'inizio. Nel seguente esempio, i 2 array verranno assegnati alle variabili V&W , anziché U& V:

Aõ
Vm²
[do something with the arrays]

Conosci il Javascript

Poiché qualsiasi codice Japt viene eseguito come JS trascritto, una buona conoscenza degli operatori JS e dei metodi integrati aiuta molto nel golfare pezzi di codice Japt.

Suggerimenti JS pertinenti

• Operatori di casting impliciti, incremento / decremento
• Alcune ricette per operatori aritmetici / bit per bit
  • Questo non necessariamente salva byte in Japt (a causa di scorciatoie), ma è sempre bene tenere presente come funzionano gli operatori.
• Conosci la virgola e l'assegnazione ovunque
  • La virgola (solitamente inserita in modo implicito in Japt) è particolarmente utile quando si desidera inizializzare una variabile e quindi fare del lavoro su di essa. Il codice seguente assegna un array vuoto a Ue quindi valuta V.m. (Avere una nuova riga attiva l'assegnazione implicita Usulla prima riga.)

[]Vm@...
...

• Corto circuito
• Dividere con i numeri
  • Questo può essere generalizzato a qualsiasi metodo che accetta stringhe ma non numeri. Un numero passato lì verrà implicitamente lanciato su una stringa, salvando spesso un byte (es. 0Over '0).

Funzioni integrate JS pertinenti

Osserva attentamente quali parametri vengono passati agli argomenti delle funzioni.

• Array.prototype.map
  • Metodi Japt correlate: Array.a/b/m/x/y/í, Number.o/õ,String.m/y/í
• Array.prototype.reduce
  • Metodi Japt correlati: Array.r/å, String.å; perché å, il quarto argomento non viene passato.
• Array.prototype.some
  • Metodo Japt correlato: Array.d
• Array.prototype.every
  • Metodo Japt correlato: Array.e

Per i metodi di stringa, è bene sapere come i comportamenti differiscono tra il passaggio di una stringa o regex con o senza gflag.

• String.prototype.match
  • Metodi Japt correlati: String.f/o
• String.prototype.search
  • Metodo Japt correlato: String.â
• String.prototype.replace
  • Metodi Japt correlati: String.e/k/r
  • Infatti e/r, passare le funzioni come secondo argomento è OK e la comprensione dei parametri della funzione è fortemente incoraggiata.

Utilizzare più righe quando necessario

Per la maggior parte delle sfide non troppo difficili, puoi esprimere la soluzione in una sola riga di Japt, come una sequenza di applicazione di funzioni integrate. Ma quelli più complessi richiederanno l'uso di costrutti ciclici, ricorsione o riutilizzo di grossi blocchi di codice. Qui entra in gioco la programmazione multilinea.

Rimuovere le parentesi di chiusura

Attività : data una matrice di numeri, accoppia ogni elemento con l'indice al quadrato e ordinalo per somma.

[5,1,17,9,3] => [[5,0],[1,1],[17,4],[9,9],[3,16]] => [[1,1],[5,0],[9,9],[3,16],[17,4]]

La soluzione a una riga è íUm@Yp2})ñx, ma })costa due byte (e non esiste un collegamento a un byte). Puoi rimuoverlo })semplicemente spostando il trailing ñxsulla riga successiva, quindi il codice è simile al seguente:

íUm@Yp2
ñx

e il JS traspilato diventa:

U = U.í(U.m(function(X, Y, Z) { return Y.p(2) })); U.ñ("x")

Puoi vedere chiaramente che questo fa la stessa cosa della soluzione a una riga, assegnando semplicemente il risultato intermedio a U.

Reclamare con argomenti impliciti

La funzione di ricorsione ßprende tutto UVWXYZcome parametro implicito, se non specificato. Uè ovviamente l'input principale, ma puoi usarne uno VWXYZper tenere traccia degli altri valori di cui hai bisogno. Ad esempio, puoi fare qualcosa di simile al seguente:

(modify input and implicit assign to U)
(modify V and implicit assign to V)
(test something and call ß without arguments; U and V are passed automatically)

In alternativa, se tutto ciò che desideri è una variabile temporanea, puoi utilizzare l'assegnazione in linea, come (T=...), come variabileT (0) viene utilizzata raramente così com'è.

Riutilizzare una funzione lunga

Per questo, non penso di riuscire a trovare un buon esempio, quindi farò riferimento all'unica soluzione utilizzata per questo suggerimento e tratterò solo alcune idee generali.

• Per riutilizzare una funzione, è necessario memorizzarla in una variabile. Avvio di una linea con la funzione di rivelazione {, @o _fa il lavoro. In alternativa, puoi anche fare qualcosa del genere(T=@...}) incorporare l'assegnazione di funzioni all'interno di una linea più complessa.
• In realtà non è banale chiamare la funzione memorizzata. Supponiamo che Vsia una funzione e che vogliamo chiamare V(U)in JS. VUnon funziona poiché significa semplicemente V,U. V(Uneanche; lo è V,(U). Anche i metodi di funzione non sono molto utili. Il modo migliore che abbiamo trovato è:
  • [U]xV (mappa e somma) se il risultato è un numero
  • UmVif Uè un singolo carattere e Vrestituisce una stringa, oppure
  • $V($Uo [U]mV gin generale.
• Tuttavia, mappare o eseguire il loop con esso è piuttosto semplice. Per mappare su un array, utilizzare UmV. Per trovare il primo numero intero che soddisfa V, utilizzare Va.

Divertimento con le funzioni automatiche

Come seguito al suggerimento generale di ETH sulle funzioni automatiche , questo suggerimento fornirà alcuni esempi specifici di trucchi per il salvataggio di byte che è possibile ottenere con essi, a cui aggiungerò come penso di più.

Ottieni il numero intero più grande in un array.

Supponiamo di avere l'array [3,1,4,2]assegnato alla variabile Ue di recuperarne il numero più grande. Abbiamo potuto fare in 4 byte di classificare la matrice e quindi spuntare l'ultimo elemento:

Un o

Il rovescio della medaglia è che abbiamo modificato l'array originale; Uè ora [1,2,3]che potrebbe non essere sempre desiderabile. Fortunatamente, c'è un modo di farlo senza modificare l'array che è anche più corto di un byte:

Urw

Ciò che abbiamo fatto è stato ridotto l'array usando il wmetodo, che, se usato su un numero intero, restituisce il più grande dell'intero e l'argomento del metodo (ad esempio, 2w5restituisce 5). Quindi quanto sopra è l'equivalente di UrÈwYo UrXY{XwY}. Si noti, tuttavia, che questo suggerimento non funzionerà nel caso in cui tutti i numeri interi nella matrice siano negativi.

Quando no usareí

í è un utile built-in che accoppia (o zip ) due array o stringhe e facoltativamente mappa ogni coppia attraverso una funzione. Tuttavia, attualmente presenta alcuni problemi minori quando vengono dati array o stringhe irregolari:

• Se il primo array ha più elementi del secondo, verranno indicati gli elementi inesistenti nel secondo undefined .
• Se il secondo array ha più elementi del primo, interromperà l'elaborazione alla fine del primo array.

Questo può rendere difficile, per esempio, confrontare due stringhe irregolari e prendere il carattere con il punto di codice più alto di ogni coppia. Anche se sai che Usarà il più lungo, ci vogliono ancora molti byte per risolvere questo semplice compito:

UíUç hV @[XY]n o

Quello che potresti fare invece sarebbe prendere l'input come una matrice di due stringhe, trasporre l'array con ye quindi mappare ogni riga sul risultato corretto:

Uy m_q n o

Questo ha il vantaggio di riempire sempre la corda più corta di spazi, rendendola un gioco da ragazzi passare attraverso tutte e due le corde.

Esempi di vita reale: 1 , 2

Genera l'intervallo ASCII

Aggiornamento: Japt ora ha una costante per l'intervallo ASCII; il valore alternativo per E, accessibile con ;. Vedi questo consiglio per ulteriori informazioni sulle costanti di Japt.

Sebbene Japt non abbia (ancora) un built-in per l'intervallo ASCII, è possibile generare una matrice di caratteri in soli 5 byte:

95odH

Provalo

Come funziona

95ocrea l'intervallo [0,95)con ciascun elemento passato attraverso la funzione automatica d che, se utilizzata su un numero, restituisce il carattere in quel punto di codice. Passa un numero come argomento ald metodo, in questo casoH , la costante Japt per 32 e verrà aggiunta al numero originale prima di essere convertita.

Una soluzione equivalente in JavaScript sarebbe:

[...Array(95)].map((_,x)=>String.fromCharCode(x+32))

Personaggi casuali

Per ottenere un carattere casuale nell'intervallo ASCII, utilizzare öinvece, che restituisce un numero casuale dall'intervallo[0,X) , dove si Xtrova il numero su cui viene eseguito.

95ö dH

Oppure, per ottenere una matrice di più caratteri casuali, passa il numero di caratteri di cui hai bisogno come argomento ö. Di seguito verranno restituiti 10 caratteri:

95öA mdH

Rimuovere i caratteri strutturali non necessari

Da caratteri strutturali, intendo {}, (), $, anche "e `. In genere è possibile rimuovere questi caratteri ogni volta che si verificano alla fine di un programma (ad esUmX{Xc +"; "} -> UmX{Xc +"; .).

Inoltre, puoi rimuovere parentesi o spazi ogni volta che compaiono nei seguenti luoghi:

• Contro un punto e virgola ; (o la fine del programma);
• A destra di {(e per estensione, @) o [, oppure a sinistra di ]o }.

Inoltre, le virgole sono molto raramente necessarie per separare gli argomenti. Se scrivi AB, per esempio, Japt sa che intendi Ae Bseparatamente. Hai solo bisogno di una virgola per separare due letterali numerici, comeUs2,5 .

Infine, se c'è un Uall'inizio di un programma o dopo una {o ;, seguito da una chiamata al metodo (minuscola o relativi scorciatoia Unicode) o di qualsiasi operatore binario escluso +e -( *, &, ==e così via), è possibile rimuovere il Uper salvare un byte e Japt lo inseriranno per te.

Modifica l'ultimo elemento in una matrice

A volte potrebbe essere necessario modificare l'ultimo elemento in un array, quindi ecco una spiegazione di un breve modo per farlo. Lavoreremo con l'array [2,4,8,32]assegnato alla variabile di input Ue dividendo l'ultimo numero intero ( 32) per 2.

Il modo ovvio per raggiungere questo obiettivo sarebbe con questa soluzione a 9 byte ( Demo ):

UhJUgJ /2

• hnximposta l'elemento su indice nsu x.
• gnrestituisce l'elemento all'indice n.
• Jè la costante di Japt per -1, che, grazie al supporto di Japt per l'indice negativo, ci consente di lavorare con l'ultimo elemento in un array; utile quando non si conoscono le dimensioni dell'array.
• Ed /2è semplicemente divisione per 2.

Così i gruppi di cui sopra l'elemento in corrispondenza dell'indice -1nella matrice all'elemento all'indice -1dell'array diviso 2. O in JavaScript: U[3]=U[3]/2. Quando lo scrivi in ​​questo modo, sembra un modo troppo complicato per farlo. Fortunatamente, c'è un modo più breve; potremmo estrarre l'ultimo elemento dall'array, modificarlo e rimandarlo all'array. L'esecuzione di ciascuna di queste operazioni singolarmente richiederebbe più di 9 byte, ma possiamo eseguirle tutte in una volta per soli 7 byte, risparmiando 2 byte ( Demo )

UpUo /2

Tradotto in JS, è l'equivalente di:

U.push(U.pop()/2)&&U