JavaScript, comprimento da linha 1, 960 956 928 bytes
[
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
)
`
Versão mais legível, que também é um quine (novas linhas externas removidas):
[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)`
Explicação
Ufa. Aceite uma carona aqui, porque esta será uma jornada traiçoeira ...
Passei muito tempo tentando descobrir como resolver esse desafio com o comprimento 1 - sem incorporar (diretamente, de qualquer maneira), palavras-chave ou até funções de seta - antes de perceber que isso é facilmente possível com o JSF *** , que pode avalie qualquer código JavaScript e evite tokens de vários bytes. Mas uma solução JSF seria facilmente de milhares de bytes, se não dezenas ou centenas de milhares. Felizmente, não estamos limitados a apenas - ()[]+!
temos todos os ASCII à nossa disposição!
Decidi começar jogando os elementos essenciais do JSF - os personagens que podem ser construídos em strings para "desbloquear mais recursos", por assim dizer. Não podemos usar strings diretamente para obter caracteres, pois isso exigiria linhas de comprimento 3. Então, em vez disso, roubamos um truque do JSF, obtendo alguns caracteres de literais que podem ser construídos com tokens de byte único:
JSF*** Used here Value Chars unlocked
!![] !0 true true
![] !1 false fals
[][[]] t.a undefined ndi
A partir disso, podemos expandir para fora, começando com [].find
, que é um objeto de Função. Convertendo isso para uma seqüência function find() { ...
nos dá acesso a c
, o
, espaço ( _
) e parênteses ( y
e z
). Talvez mais importante, agora temos acesso à sua constructor
, a Function
função-que, inceptional que possa parecer, nos dá a capacidade de executar código através da construção de uma corda, passando-a para Function()
, em seguida, chamar a função gerada.
Eu provavelmente mencionaria o método geral usado pelo próprio programa. A partir de 2015, o JavaScript tem esse recurso muito legal chamado " modelos marcados " , que não apenas permite novas linhas sem escape em cadeias de caracteres, mas também permite chamar uma função com uma literal de cadeia diretamente (de certa forma; myFunc`abc`;
é aproximadamente equivalente a myFunc(["abc"])
). Se colocarmos a chamada de função como a última coisa no programa, a estrutura geral ficará assim:
code;func`code;func`
Tudo o que func
precisa fazer é emitir seu argumento, seguido por um backtick, depois seu argumento novamente e um segundo backtick. Supondo que temos o argumento a
e um backtick armazenados f
, podemos fazer isso com o código alert(a+f+a+f)
. No entanto, no momento, estamos perdendo +
e o próprio bastão. +
(armazenado em P
) não é difícil; roubamos outro truque do JSF, construindo a string 1e23
, convertendo em um número, depois voltando a uma string, dando "1e+23"
.
Conseguir um backtick é um pouco mais complicado. No começo, tentei obter String.fromCharCode
, mas encontrar um C
resultado quase tão difícil. Felizmente, atob
é fácil de obter ( Function("return atob")()
; b
é gerado a partir de 0+{}
, o que fornece [object Object]
) e pode fornecer qualquer caractere ASCII, se uma string mágica apropriada for encontrada. Um pequeno script me deu 12A
como uma das opções, que podem ser convenientemente encontrados em 12Array
(um pouco mais curto para gerar, graças a [].constructor[n+a+m+e]
; m
é encontrado em 0 .constructor+0
: "function Number() { ..."
).
Finalmente, juntamos tudo. Atribuímos o backtick à variável f
, mas, como não podemos usá-lo diretamente na cadeia de funções, definimos a variável q
como letra f
e, em vez disso, a usamos. Isso torna nossa string final a+l+e+r+t+y+a+P+q+P+a+P+q+z
, ou "alert(a+f+a+f)"
. Em seguida, alimentamos isso Function()
, alimentamos o código final para o resultado e, voila, temos um código JavaScript com não mais que um caractere por linha!
Minha cabeça está péssima no momento, por isso, pergunte sobre os erros que cometi ou sobre as coisas que perdi nesta explicação, e voltarei a responder depois de descansar um pouco ...