JavaScript, longitud de línea 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
)
`
Versión más legible que también resulta ser una quine (se eliminan nuevas líneas extrañas):
[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)`
Explicación
Uf. Acomódate para dar un paseo aquí, porque este será un viaje traicionero ...
Pasé mucho tiempo tratando de descubrir cómo resolver este desafío con la longitud 1, sin funciones integradas (directamente, de todos modos), palabras clave o incluso funciones de flecha, antes de darme cuenta de que es posible fácilmente con JSF *** , que puede evalúe cualquier código JavaScript mientras evita los tokens de varios bytes. Pero una solución JSF fácilmente tendría una longitud de miles de bytes, si no decenas o cientos de miles. Afortunadamente, no estamos limitados a solo: ¡ ()[]+!tenemos todo ASCII a nuestra disposición!
Decidí comenzar jugando al golf los bloques de construcción esenciales de JSF, los personajes que se pueden construir en cadenas para "desbloquear más funciones", por así decirlo. No podemos usar cadenas directamente para obtener caracteres, ya que eso requeriría líneas de longitud 3. Entonces, en su lugar, robamos un truco de JSF, obteniendo algunos caracteres de literales que se pueden construir con tokens de un solo byte:
JSF*** Used here Value Chars unlocked
!![] !0 true true
![] !1 false fals
[][[]] t.a undefined ndi
De estos podemos expandirnos hacia afuera, comenzando con [].find, que es un objeto Function. Convirtiendo esta en una cadena function find() { ...nos da acceso a c, o, espacio ( _), y entre paréntesis ( yy z). Quizás lo más importante, ahora tenemos acceso a su constructor, la Functionfunción -que, inceptional que pueda parecer, nos da la capacidad de ejecutar código mediante la construcción de una cadena, pasándolo a Function(), y luego llamar a la función generada.
Probablemente debería mencionar el método general utilizado por el programa en sí. A partir de 2015, JavaScript tiene esta característica realmente genial llamada " plantillas etiquetadas " , que no solo permite nuevas líneas sin escapes en las cadenas, sino que también nos permite llamar a una función con un literal de cadena directamente (de alguna manera; myFunc`abc`;es más o menos equivalente a myFunc(["abc"])). Si ponemos la llamada a la función como la última cosa en el programa, la estructura general se verá así:
code;func`code;func`
Todo lo que functiene que hacer es generar su argumento, seguido de un retroceso, luego su argumento nuevamente y un segundo retroceso. Suponiendo que tenemos el argumento ay un backtick almacenado f, podemos lograr esto con el código alert(a+f+a+f). Sin embargo, por el momento, nos falta +y el backtick en sí. +(almacenado en P) no es difícil; Robamos otro truco de JSF, construimos la cadena 1e23, la convertimos en un número, luego volvemos a una cadena y damos "1e+23".
Obtener un backtick es un poco más complicado. Al principio, intenté obtenerlo String.fromCharCode, pero encontrar uno Cresultó ser casi tan difícil. Afortunadamente, atobes bastante fácil de obtener ( Function("return atob")(); bse genera a partir 0+{}, lo que da [object Object]) y puede dar cualquier carbón ASCII, si se encuentra una cadena mágica adecuada. Una breve secuencia de comandos me dio 12Acomo una de las opciones, que se puede encontrar convenientemente en 12Array(un poco más corto para generar, gracias a [].constructor[n+a+m+e]; mse encuentra en 0 .constructor+0:) "function Number() { ...".
Finalmente, unimos todo. Asignamos el backtick a variable f, pero como no podemos usarlo directamente en la cadena de función, en su lugar establecemos variable qen la letra fy usamos eso en su lugar. Esto hace nuestra cadena final a+l+e+r+t+y+a+P+q+P+a+P+q+z, o "alert(a+f+a+f)". Luego alimentamos esto Function(), enviamos nuestro código terminado al resultado, y listo, ¡tenemos una quine de JavaScript con no más de un carácter por línea!
Mi cabeza se siente terrible en este momento, así que por favor pregunte sobre cualquier error que haya cometido o sobre cosas que me haya perdido en esta explicación, y me pondré en contacto con usted después de descansar un poco ...