oder: Bauen Sie eine vertikale Quine

^{Inspiriert von Stell dich gegen lange Schlangen .}

Ihre Aufgabe ist es, eine vertikale Quine mit einer möglichst kurzen Linienlänge zu erstellen.

Wertung

Die kürzeste Linienlänge (ohne Newlines) gewinnt mit Code-Golf- Kriterien als Tie-Breaker.

Die Zeilenlänge wird als die längste Zeile in Ihrem Programm mit Ausnahme des Zeilenumbruchzeichens bestimmt.

Beispielsweise:

$_=
Q.
P

hat eine Zeilenlänge von 3 und eine Byteanzahl von 8, während:

Q
$
_
P

Hat eine Zeilenlänge von 1 und eine Byteanzahl von 7 (vorausgesetzt, keine nachgestellte Zeile).

Regeln

Quines müssen der Community-Definition eines Quines entsprechen .

Standardlücken sind verboten.

Sprache , Zeilenlänge 0, 1,01 × 10 ⁸⁰⁵ Bytes

Der Quellcode besteht aus

10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943

Zeilenumbrüche, die das folgende Brainfuck-Programm codieren.

>>++++++++>+++>+++>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>++++++++>++++>++++++++>++++>+++++++>++>+++>+>+++>++>+++>+++>+>+>+>+>+>+>+>+>++++>++++>+++++++>+>++++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++++>+>+>+>+>+>+>+>+>+>+>++++++++>++++>+++++++>+++++++>+>+>+++>+>+>+>++++++++>+++>+++++++>+>+++>+>+++>+>+++>+>++++++++>++++>++++++++>++++>++++++++>++++>++++>+>+++>+++>++>+++++++>+++++++>+>+>+>++++++++>+++>+>++++++++>++++>+>+++>++>+++++++>++>+++++++>++++>++++>++++++++>+++>++++++++>+++>+++>+>++++>++++>++>+++++++>+++>+++>++++++++>++++>+>+++>++>+++++++>++++>++++>+++++++>+++>+++>+++>+++>++++++++>++++>++++>+>+++>+>+++>++>+++++++>+++++++
[
    [->+>+<<]
    >>>>[<<[->+<]>>[-<<+>>]>]
    <<[-[->+<]+>]+++
    [[->>+<<]<]<
]
+>+>+>+
[>]+++>++
[
    [<]++++++++++.[-]
    >[-]>[-]>[-]>[-]
    <+[<<++++++++>>->+>-[<]<]
    ++++++++>++++++++>+++++++>>
]

Der Quellcode ist weitgehend identisch zu @ jimmy23013 Strahlungs erweichten Lenguage quine , abzüglich der .am Ende mit ++++++++++.[-]ersetzen .1 Zeilenvorschübe anstelle von null Bytes, und die entsprechenden Änderungen an den Daten Schnitt entlang der Linie zu drucken.

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 ...

Haskell , Zeilenlänge 6, 400 343 336 Bytes

{main=
putStr
$s++(s
>>=(++
":\n")
.show)
++
"[]}";
s='{':
'm':
'a':
'i':
'n':
'=':
'\n':
'p':
'u':
't':
'S':
't':
'r':
'\n':
'$':
's':
'+':
'+':
'(':
's':
'\n':
'>':
'>':
'=':
'(':
'+':
'+':
'\n':
'"':
':':
'\\':
'n':
'"':
')':
'\n':
'.':
's':
'h':
'o':
'w':
')':
'\n':
'+':
'+':
'\n':
'"':
'[':
']':
'}':
'"':
';':
'\n':
's':
'=':
[]}

Probieren Sie es online! Mir ist kein Umweg bekannt putStr, daher die Zeilenlänge von 6. Die äußeren geschweiften Klammern ermöglichen es, den anderen erforderlichen Einzug nach einer neuen Zeile innerhalb einer einzelnen Deklaration zu entfernen.

> <> , 22 Bytes, Zeilenlänge 1

/
v
o
a
o
^
}
-
d
:
"

Probieren Sie es online!

-6 Bytes dank Emigna .

CJam , Zeilenlänge 1, 16 13 Bytes

"
_
p
"

_
p

Probieren Sie es online!

Es ist ein kleines Wunder, dass das Einfügen von Zeilenumbrüchen in die Standard-Quine und{"_~"}_~ noch kürzere Standard-Quine "_p"␊_pdas Richtige bewirkt. (Danke, Martin!) Der abschließende Zeilenumbruch ist notwendig.

Erklärung (mit • als Newline)

"•_•p•"        Push that string.
       ••      Do nothing.
         _     Duplicate the string.
          •    Do nothing.
           p   Pop it and print it with quotes and a newline: "•_•p•"•
            •  Do nothing.

Beim Beenden wird gedruckt ( •_•p•), was auf dem Stapel übrig bleibt , was die Gesamtausgabe ergibt "•_•p•"••_•p•.

Haskell + CPP, Zeilenlänge 2, 705 237 Bytes

m\
a\
i\
n\
=\
p\
u\
t\
S\
t\
r\
$\
(\
:\
"\
\\
\\
\\
n\
"\
)\
=\
<\
<\
s\
+\
+\
s\
h\
o\
w\
 \
s\
;\
s\
=\
"\
m\
a\
i\
n\
=\
p\
u\
t\
S\
t\
r\
$\
(\
:\
\\
"\
\\
\\
\\
\\
\\
\\
n\
\\
"\
)\
=\
<\
<\
s\
+\
+\
s\
h\
o\
w\
 \
s\
;\
s\
=\
"\

Probieren Sie es online! Flagge benutzen-CPP , das den C-Pre-Prozessor aktiviert, können Sie einen Backslash am Ende einer Zeile verwenden, um ihn in der nächsten Zeile fortzusetzen.

Der eigentliche Code ist main=putStr$(:"\\\n")=<<s++show s;s="<data>".

Edit: Ein lässiges -468 Byte dank Ørjan Johansen !

Rust, Zeilenlänge: 5, Bytes: 301 299

Probieren Sie es online aus

Ungeachtet des Aussehens ist dies keine esoterische Programmiersprache, es gibt nur viel Zeilenrauschen im Format.

Vertikale Länge von 5 wurde gewählt, um verwenden zu können print. Ich glaube nicht, dass es einen Weg zum Drucken gibt, der eine kürzere vertikale Länge hätte, wenn man C-Funktionen als externSchlüsselwort deklariert, stdout6 Bytes lang writeist, 5 Bytes lang no_mainist, 7 Bytes lang ist (main ist normalerweise eine Funktion;)).

fn
main
(){
let
t=(
r#"fn
main
(){
let
t=("#
,r#")
;
print
!(
r#"{}
r#"{
}"{}
,r#"{
}"{},
r#"{
}"{}
{}{}{
}{
}""#,
r#"
,t.0,
t.0,
'#',
t.1,
'#',
t.2,
'#',
t.1,
'#',
t.2,
'}'
)"#
)
;
print
!(
r#"{}
r#"{
}"{}
,r#"{
}"{},
r#"{
}"{}
{}{}{
}{
}"#
,t.0,
t.0,
'#',
t.1,
'#',
t.2,
'#',
t.1,
'#',
t.2,
'}'
)}

05AB1E , Zeilenlänge: 1, Byteanzahl : 43

2
"
D
3
4
«
ç
¶
ì
ý
Ô
"
D
3
4
«
ç
¶
ì
ý
Ô

Probieren Sie es online!

Japt , Zeilenlänge 1, 20 Bytes

Basierend auf dem Standard Japt Quine von ETHproductions .

"
ich
Q.

²
"
ich
Q.

²

Probieren Sie es hier aus!

JavaScript (ES6), Zeilenlänge 3, 17 Byte

f=
_=>
`f=
${f
}`

Rot , Zeilenlänge: 10, 49 Bytes

s: [prin [
    "s:"
    mold s
    "do s"
]] do s

Probieren Sie es online!

Dies ist in der Tat ein Rebol Quine

Erläuterung: Rot / Rebol moldfolgt dem Codierungsstil, bei dem 4 Leerzeichen versetzt werden.

s: [prin [     ; s is a block; print the following: 
    "s:"       ; literal "s:"
    mold s     ; the representation of the block itself - all between []
    "do s"     ; literal "do s"
]] do s        ; evaluate the block

RProgN , 3 Bytes, Zeilenlänge 1

0
0

Probieren Sie es online!

Eine Kopie von Dennis 'Antwort hier (go upvote er auch)

Dies entspricht unserer aktuellen Definition eines richtigen Quines, da die erste 0 die zweite 0 codiert und umgekehrt.

RProgN 2 , L = 1, B = 15 Bytes

«
Ø
.
`
-
S
`
.

Dies entspricht dem Programm:

«Ø.`
-S`
.

Nervenzusammenbruch

«Überträgt zuerst eine Funktion, die implizit den Rest des Programms darstellt, auf den Stapel und setzt dann die Ausführung fort. Ø.Hängt eine leere Zeichenfolge an die Funktion an, wodurch sie stringiert wird. Dies wird sich immer wie das gleichberechtigte Programm verhalten, da die Zeilenumbrüche nicht ausgeführt werden. `\n-Entfernt alle Zeilenumbrüche aus dem String, die jetzt so aussehen «Ø.`=S`.. Skonvertiert es dann in einen Stapel einzelner Zeichen und `\n.fügt den Stapel durch Zeilenumbrüche hinzu, wobei das erwartete Programm zurückgegeben wird.

Probieren Sie es online!

Unterlast , Zeilenlänge 1, 20 Bytes

(
:
a
S
S
)
:
a
S
S

Probieren Sie es online!

Dies ist nur die Standard-Unterlast-Quine mit angehängten Zeilenumbrüchen. Erfordert eine Implementierung wie die TIO, die unbekannte Befehlszeichen ignoriert.

Das Teil in ()ist ein String-Literal, das auf den Stapel gelegt, :dupliziert, aden obersten Stapeleintrag in Klammern eingeschlossen und Sgedruckt wird.

Perl 5 , 259 Bytes

$
_
=
p
.
r
.
i
.
n
.
t
.
q
{

'
$
_
=
p
.
r
.
i
.
n
.
t
.
q
{
'
,
&
{
I
.
"
X
0
y
h
~
"
^
"
E
O
0

y
"
.
x
}
(
$
_
,
6
,
-
1
)
,
'
}
;
&
{
I
.
"
X
0
o
k
h
~
"
.
(
Y
|
p
)
^
"
E
O
0
|
f
s
o
"
}
'
}
;
&
{
I
.
"
X
0
o
k
h
~
"
.
(
Y
|
p
)
^
"
E
O
0
|
f
s
o
"
}

Probieren Sie es online!

Überprüfung .

Javascript (ES6 REPL), Vollprogramm, Zeilenlänge: 3, Byteanzahl: 31

(
f=
_=>
`(
f=
${f
}
)
()`
)
()

Dies ist eine Portierung von @ kamoroso94s Antwort auf ein in sich geschlossenes vollständiges Programm.

Wenn jemand eine Möglichkeit findet, einige Bytes zu entfernen, ohne die Zeilenlänge zu erhöhen, kann er gerne einen Kommentar abgeben :)

Pip , Zeilenlänge 1, 35 Bytes

V
Y
"
[
`
V
Y
`
y
]
.
C
:
3
.
4
"

Probieren Sie es online!

Basierend auf dem kürzesten bekannten Pip Quine V Y"`V Y`.RPy". Die Hauptschwierigkeit beim Quetschen auf Linienlänge 1 istRP , dass diese nicht auf zwei Linien aufgeteilt werden kann. Aber in diesem Fall alleRP (repr) tut, den String in doppelte Anführungszeichen zu setzen, was wir direkt tun können.

Hier ist eine Erklärung basierend auf einer horizontalen Version:

V Y"[`V Y`y].C:3. 4"
  Y"               "  Yank this string into the variable y
V                     and eval it
                      The code that is eval'd:
    [      ]           Build a list containing:
     `V Y`              this Pattern object (used for regex, but here useful as a
                          string-like object that doesn't need double quotes)
          y             y, the whole string
               3. 4    Concatenate 3 and 4 to make 34 (since the 2-digit number won't work
                         in the vertical version)
             C:        Convert to ASCII character (: forces the precedence lower than .)
            .          Concatenate the " to the end of each list element
                      The resulting list is printed, concatenated together, with a
                        trailing newline

Befunge-98 , 41 Bytes

^
@
,
,
a
-
1
*
5
7
|
 
#
!
a
#
:
,
^
$
"

Probieren Sie es online!

Wirklich nur ein normaler Quine, der seitwärts gedreht wurde, mit ein paar Extras zum Drucken von Zeilenumbrüchen.