JavaScript, lunghezza linea 1, 960 956 928 byte
[
t
,
r
,
u
,
e
,
f
,
a
,
l
,
s
]
=
!
0
+
[
!
1
]
;
[
,
n
,
d
,
,
q
,
i
]
=
t
.
a
+
t
V
=
[
]
[
f
+
i
+
n
+
d
]
;
[
,
,
,
c
,
,
,
o
,
,
_
,
,
,
,
,
y
,
z
]
=
V
+
0
F
=
V
[
E
=
c
+
o
+
n
+
s
+
t
+
r
+
u
+
c
+
t
+
o
+
r
]
P
=
(
1
+
e
+
2
+
3
-
4
+
t
)
[
2
]
f
=
F
(
r
+
e
+
t
+
u
+
r
+
n
+
_
+
a
+
t
+
o
+
(
0
+
{
}
)
[
3
]
)
(
)
(
3
*
4
+
[
]
[
E
]
[
n
+
a
+
(
0
[
E
]
+
0
)
[
9
+
2
]
+
e
]
)
[
1
]
F
(
a
,
a
+
l
+
e
+
r
+
t
+
y
+
a
+
P
+
q
+
P
+
a
+
P
+
q
+
z
)
`
[
t
,
r
,
u
,
e
,
f
,
a
,
l
,
s
]
=
!
0
+
[
!
1
]
;
[
,
n
,
d
,
,
q
,
i
]
=
t
.
a
+
t
V
=
[
]
[
f
+
i
+
n
+
d
]
;
[
,
,
,
c
,
,
,
o
,
,
_
,
,
,
,
,
y
,
z
]
=
V
+
0
F
=
V
[
E
=
c
+
o
+
n
+
s
+
t
+
r
+
u
+
c
+
t
+
o
+
r
]
P
=
(
1
+
e
+
2
+
3
-
4
+
t
)
[
2
]
f
=
F
(
r
+
e
+
t
+
u
+
r
+
n
+
_
+
a
+
t
+
o
+
(
0
+
{
}
)
[
3
]
)
(
)
(
3
*
4
+
[
]
[
E
]
[
n
+
a
+
(
0
[
E
]
+
0
)
[
9
+
2
]
+
e
]
)
[
1
]
F
(
a
,
a
+
l
+
e
+
r
+
t
+
y
+
a
+
P
+
q
+
P
+
a
+
P
+
q
+
z
)
`
Versione più leggibile che sembra essere anche una quine (rimosse le nuove righe estranee):
[t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t
V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0
F=V[E=c+o+n+s+t+r+u+c+t+o+r]
P=(1+e+2+3-4+t)[2]
f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(3*4+[][E][n+a+(0[E]+0)[9+2]+e])[1]
F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)`
[t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t
V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0
F=V[E=c+o+n+s+t+r+u+c+t+o+r]
P=(1+e+2+3-4+t)[2]
f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(3*4+[][E][n+a+(0[E]+0)[9+2]+e])[1]
F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)`
Spiegazione
Accidenti. Accomodati a fare un giro qui, perché questo sarà un viaggio infido ...
Ho trascorso molto tempo a cercare di capire come risolvere questa sfida con la lunghezza 1 - nessun built-in (direttamente, comunque), parole chiave o persino funzioni freccia - prima di rendermi conto che è facilmente possibile con JSF *** , che può valutare qualsiasi codice JavaScript evitando token multi-byte. Ma una soluzione JSF sarebbe facilmente lunga migliaia di byte, se non decine o centinaia di migliaia. Per fortuna, non ci limitiamo a solo: ()[]+!abbiamo tutta l'ASCII a nostra disposizione!
Ho deciso di iniziare giocando a golf gli elementi costitutivi essenziali di JSF, i personaggi che possono essere integrati in stringhe per "sbloccare più funzionalità", per così dire. Non possiamo usare direttamente le stringhe per ottenere caratteri, poiché ciò richiederebbe linee di lunghezza 3. Quindi, invece, rubiamo un trucco da JSF, ottenendo alcuni caratteri dai letterali che possono essere creati con token a byte singolo:
JSF*** Used here Value Chars unlocked
!![] !0 true true
![] !1 false fals
[][[]] t.a undefined ndi
Da questi possiamo espandere verso l'esterno, a partire da [].find, che è un oggetto Funzione. La conversione di questo in una stringa function find() { ...ci dà l'accesso a c, o, spazio ( _), e le parentesi ( ye z). Forse ancora più importante, ora abbiamo accesso alla sua constructor, la Functionfunzione - che, per quanto possa sembrare iniziale, ci dà la possibilità di eseguire il codice costruendo una stringa, passandola a Function(), e quindi chiamando la funzione generata.
Dovrei probabilmente menzionare il metodo generale utilizzato dal programma stesso. A partire dal 2015, JavaScript ha questa caratteristica davvero interessante chiamata " modelli con tag " , che non solo consente di creare nuove righe senza caratteri di escape nelle stringhe, ma ci permette anche di chiamare direttamente una funzione con una stringa letterale (in un certo senso; myFunc`abc`;è approssimativamente equivalente a myFunc(["abc"])). Se inseriamo la funzione call come ultima cosa nel programma, la struttura generale sarà simile a questa:
code;func`code;func`
Tutto ciò che funcdeve fare è quindi generare il suo argomento, seguito da un backtick, quindi di nuovo dal suo argomento e da un secondo backtick. Supponendo che abbiamo l'argomento ae un backtick archiviato f, possiamo farlo con il codice alert(a+f+a+f). Tuttavia, al momento, ci manca +e il backtick stesso. +(memorizzato in P) non è difficile; rubiamo un altro trucco da JSF, costruendo la stringa 1e23, convertendola in un numero, quindi di nuovo in una stringa, dando "1e+23".
Ottenere un backtick è un po 'più complicato. All'inizio, ho cercato di ottenere String.fromCharCode, ma trovando che Csi è rivelato quasi altrettanto difficile. Fortunatamente, atobè abbastanza facile da ottenere ( Function("return atob")(); bè generato da 0+{}, che dà [object Object]) e può dare qualsiasi carattere ASCII, se viene trovata una stringa magica adeguata. Un breve script mi ha dato 12Acome una delle opzioni, che può essere facilmente trovata in 12Array(un po 'più breve da generare, grazie a [].constructor[n+a+m+e]; msi trova in 0 .constructor+0:) "function Number() { ...".
Alla fine, mettiamo tutto insieme. Assegniamo il backtick alla variabile f, ma poiché non possiamo usarlo direttamente nella stringa della funzione, invece impostiamo la variabile qsulla lettera fe la usiamo invece. Questo rende la nostra stringa finale a+l+e+r+t+y+a+P+q+P+a+P+q+z, o "alert(a+f+a+f)". Quindi lo Function()inseriamo, il risultato è il nostro codice finito e, voilà, abbiamo un quine JavaScript con non più di un carattere per riga!
La mia testa è terribile al momento, quindi per favore informati su eventuali errori che ho fatto o cose che mi sono perso in questa spiegazione, e ti risponderò dopo aver riposato ...