JavaScript, Zeilenlänge 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
)
`
Lesbarere Version, die auch eine Quine ist (überflüssige Zeilenumbrüche entfernt):
[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)`
Erläuterung
Wütend. Machen Sie es sich hier gemütlich, denn das wird eine verräterische Reise ...
Ich habe lange versucht, herauszufinden, wie diese Herausforderung mit Länge 1 gelöst werden kann - ohne eingebaute (direkt), Schlüsselwörter oder sogar Pfeilfunktionen -, bevor mir klar wurde, dass dies mit JSF *** problemlos möglich ist Bewerten Sie jeden JavaScript-Code und vermeiden Sie Multibyte-Token. Aber eine JSF-Lösung wäre leicht Tausende von Bytes lang, wenn nicht Zehntausende oder Hunderttausende. Zum Glück sind wir nicht nur darauf beschränkt - wir ()[]+!verfügen über alle ASCII-Funktionen!
Ich beschloss, zunächst die wesentlichen Bausteine von JSF zu spielen - die Charaktere, die zu Strings zusammengesetzt werden können, um sozusagen "mehr Funktionen freizuschalten". Wir können Zeichenfolgen nicht direkt zum Abrufen von Zeichen verwenden, da dies Zeilen mit der Länge 3 erfordern würde. Stattdessen stehlen wir JSF einen Trick und erhalten ein paar Zeichen aus Literalen, die mit Einzelbyte-Token erstellt werden können:
JSF*** Used here Value Chars unlocked
!![] !0 true true
![] !1 false fals
[][[]] t.a undefined ndi
Von diesen können wir nach außen expandieren, beginnend mit [].find, welches ein Funktionsobjekt ist. Umwandlung in einen Stringfunction find() { ... gibt uns Zugriff auf c, ein oRaum ( _) und Klammern ( yund z). Vielleicht noch wichtiger ist, dass wir jetzt Zugriff auf constructordie FunctionFunktion haben, die uns, so ungewöhnlich sie auch klingt, die Möglichkeit gibt, Code auszuführen, indem wir eine Zeichenfolge erstellen, an diese übergeben Function()und dann die generierte Funktion aufrufen.
Ich sollte wahrscheinlich die vom Programm selbst verwendete Gesamtmethode erwähnen. Seit 2015 hat JavaScript diese wirklich coole Funktion namens " Tagged Templates ", die nicht nur Zeilenumbrüche in Zeichenfolgen zulässt, sondern auch den direkten Aufruf einer Funktion mit einem Zeichenfolgenliteral ermöglicht (in gewisser Weise myFunc`abc`;entspricht dies in etwa myFunc(["abc"])). Wenn wir den Funktionsaufruf als letztes in das Programm aufnehmen, sieht die allgemeine Struktur so aus:
code;func`code;func`
Alles func, was Sie dann tun müssen, ist die Ausgabe des Arguments, gefolgt von einem Backtick, dann erneutem Argument und einem zweiten Backtick. Angenommen, wir haben das Argument in aund ein Backtick in gespeichert f, können wir dies mit dem Code erreichenalert(a+f+a+f) . Im Moment fehlen uns jedoch +und das Backtick selbst. +(gespeichert in P) ist nicht schwer; Wir stehlen JSF einen weiteren Trick, bauen den String auf 1e23, wandeln ihn in eine Zahl um und geben dann wieder einen String "1e+23".
Einen Backtick zu bekommen ist etwas komplizierter. Zuerst versuchte ich es String.fromCharCode, aber es Cstellte sich heraus, dass es fast genauso schwierig war , eine zu finden. Glücklicherweise atobist es einfach genug zu bekommen ( Function("return atob")(); bwird generiert aus 0+{}, was gibt [object Object]) und kann jedes ASCII-Zeichen geben, wenn eine richtige magische Zeichenfolge gefunden wird. Ein kurzes Skript gab mir 12Aals eine der Optionen an, die bequem in zu finden sind12Array (etwas kürzer zu generieren, dank [].constructor[n+a+m+e]; mist in zu finden 0 .constructor+0:) "function Number() { ...".
Zum Schluss halten wir alles zusammen. Wir weisen den Backtick der Variablen zu f, aber da wir ihn nicht direkt in der Funktionszeichenfolge verwenden können, setzen wir die Variable stattdessen qauf den Buchstabenf und verwenden sie stattdessen. Dies macht unsere letzte Saite a+l+e+r+t+y+a+P+q+P+a+P+q+z, oder "alert(a+f+a+f)". Wir geben dies dann an Function(), geben den fertigen Code an das Ergebnis weiter und voila, wir haben eine JavaScript-Quine mit nicht mehr als einem Zeichen pro Zeile!
Mein Kopf fühlt sich im Moment schrecklich an. Bitte erkundigen Sie sich nach Fehlern oder Dingen, die ich in dieser Erklärung übersehen habe, und ich melde mich bei Ihnen, nachdem ich mich etwas ausgeruht habe ...