lub: Zbuduj pionowy quine

^{Zainspirowany przez: Stań przy długich liniach .}

Twoim zadaniem jest zbudowanie pionowej kabiny o możliwie najkrótszej długości linii.

Punktacja

Zwycięża najkrótsza linia (z wyłączeniem nowych linii), z kryterium golfa jako rozstrzygającym.

Długość linii jest określana jako najdłuższa linia w twoim programie, z wyłączeniem znaku końca linii.

Na przykład:

$_=
Q.
P

ma długość linii 3 i liczbę bajtów 8, podczas gdy:

Q
$
_
P

Ma długość linii 1 i liczbę bajtów 7 (zakładając, że nie ma końca nowej linii).

Zasady

Quines musi spełniać wspólnotową definicję quine .

Standardowe luki są zabronione.

Lenguage , długość linii 0, ≈ 1,01 × 10 ⁸⁰⁵ bajtów

Kod źródłowy składa się z

10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943

linefeeds, który koduje następujący program do pieprzenia mózgów.

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

Kod źródłowy jest w większości identyczny z zmiękczonym promieniowaniem quine Lenguage @ minus .na końcu, z ++++++++++.[-]zastąpieniem .wydruku linii zamiast bajtów zerowych i odpowiednich zmian w sekcji danych w linii 1.

JavaScript, długość linii 1, 960 956 928 bajtów

[
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
)
`

Bardziej czytelna wersja, która również jest quine (usunięto zbędne znaki nowej linii):

[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)`

Wyjaśnienie

Uff Wybierz się tutaj na przejażdżkę, ponieważ będzie to zdradziecka podróż ...

Spędziłem dużo czasu próbując dowiedzieć się, jak rozwiązać to wyzwanie z długością 1 - bez wbudowanych (bezpośrednio, w każdym razie), słów kluczowych, a nawet funkcji strzałek - zanim zdałem sobie sprawę, że jest to możliwe z JSF *** , który może oceń dowolny kod JavaScript, unikając jednocześnie tokenów wielobajtowych. Ale rozwiązanie JSF z łatwością miałoby tysiące bajtów, jeśli nie dziesiątki lub setki tysięcy. Na szczęście nie ograniczamy się tylko do - ()[]+!mamy do dyspozycji wszystkie ASCII!

Postanowiłem zacząć od gry w golfa w podstawowe elementy JSF - postaci, które można zbudować z ciągów znaków, aby „odblokować więcej funkcji”. Nie możemy używać ciągów bezpośrednio do pobierania znaków, ponieważ wymagałoby to wierszy o długości 3. Zamiast tego kradniemy sztuczkę z JSF, uzyskując kilka znaków z literałów, które można zbudować za pomocą tokenów jednobajtowych:

JSF***   Used here   Value        Chars unlocked
!![]     !0          true         true
![]      !1          false        fals
[][[]]   t.a         undefined    ndi

Z nich możemy rozwinąć na zewnątrz, zaczynając od [].find, który jest obiektem funkcji. Konwersja to ciąg function find() { ...daje nam dostęp do c, oprzestrzeń ( _) i nawiasy ( yi z). Co ważniejsze, mamy teraz dostęp do swojego constructor, z Functionfunkcją-które inceptional jak się może wydawać, daje nam możliwość wykonywania kodu budując łańcuch, mijając go Function(), a następnie wywołaniu funkcji generowane.

Powinienem chyba wspomnieć o ogólnej metodzie stosowanej przez sam program. Począwszy od 2015 r. JavaScript ma tę naprawdę fajną funkcję zwaną „ szablonami otagowanymi ”, która nie tylko pozwala na nieoznaczone znaki nowej linii w ciągach, ale także pozwala nam wywoływać funkcję z dosłownym ciągiem znaków (w pewnym sensie; myFunc`abc`;jest mniej więcej równoważna myFunc(["abc"])). Jeśli umieścimy wywołanie funkcji jako ostatnią rzecz w programie, ogólna struktura będzie wyglądać następująco:

code;func`code;func`

Wszystko, funcco należy zrobić, to wypisanie argumentu, następnie kliknięcie wstecz, następnie argument ponownie i drugi zwrot. Zakładając, że mamy argument ai zapisany backtick f, możemy to zrobić za pomocą kodu alert(a+f+a+f). Jednak w tej chwili brakuje, +a sam backtick. +(przechowywane w P) nie jest trudne; kradniemy kolejną sztuczkę z JSF, budując ciąg 1e23, konwertując na liczbę, a następnie z powrotem na ciąg, dając "1e+23".

Użycie backticka jest nieco bardziej skomplikowane. Na początku próbowałem uzyskać String.fromCharCode, ale znalezienie Cokazało się prawie tak samo trudne. Na szczęście atobjest łatwy do uzyskania ( Function("return atob")(); bjest generowany z 0+{}, co daje [object Object]) i może dać dowolny znak ASCII, jeśli zostanie znaleziony odpowiedni ciąg magiczny. Krótki skrypt dał mi 12Ajako jedną z opcji, które można łatwo znaleźć w 12Array(nieco krótszy wygenerować dzięki [].constructor[n+a+m+e]; mznajduje się w 0 .constructor+0: "function Number() { ...").

Wreszcie, wszystko trzymamy razem. Przypisujemy strzałkę wsteczną do zmiennej f, ale ponieważ nie możemy jej użyć bezpośrednio w ciągu funkcji, zamiast tego ustawiamy zmienną qna literę fi używamy jej zamiast tego. To czyni nasz ostatni ciąg a+l+e+r+t+y+a+P+q+P+a+P+q+z, lub "alert(a+f+a+f)". Następnie Function()podajemy to do, podajemy gotowy kod do wyniku i voila, mamy skrypt JavaScript z nie więcej niż jednym znakiem w wierszu!

W tej chwili czuję się okropnie, więc proszę pytać o błędy, które popełniłem lub rzeczy, które mi umknęły w tym wyjaśnieniu, a wrócę do ciebie po odpoczynku ...

Haskell , długość linii 6, 400 343 336 bajtów

{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':
'=':
[]}

Wypróbuj online! Nie znam sposobu na obejście putStr, dlatego długość linii wynosi 6. Zewnętrzne nawiasy klamrowe pozwalają pozbyć się innego wymaganego wcięcia po nowej linii w obrębie jednej deklaracji.

> <> , 22 bajty, długość linii 1

/
v
o
a
o
^
}
-
d
:
"

Wypróbuj online!

-6 bajtów dzięki Emignie .

CJam , długość linii 1, 16 13 bajtów

"
_
p
"

_
p

Wypróbuj online!

To mały cud, że wstawianie nowego wiersza w standardowej quinie,{"_~"}_~ nawet krótsza standardowa quina, "_p"␊_probi dobrze. (Dzięki, Martin!) Końcowy znak nowej linii jest konieczny.

Objaśnienie (z • jako nowy wiersz)

"•_•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.

Po zakończeniu drukowane jest to, co zostało na stosie ( •_•p•), uzyskując całkowitą wydajność "•_•p•"••_•p•.

Haskell + CPP, długość linii 2, 705 237 bajtów

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\
=\
"\

Wypróbuj online! Użycie flagi, -CPPktóra włącza preprocesor C, pozwala nam użyć ukośnika odwrotnego na końcu linii, aby kontynuować ją w następnej linii.

Rzeczywisty kod to main=putStr$(:"\\\n")=<<s++show s;s="<data>".

Edycja: Dorywczo -468 bajtów dzięki Ørjan Johansen !

Rdza, długość linii: 5, bajty: 301 299

Wypróbuj online

Pomimo tego, jak to wygląda, nie jest to ezoteryczny język programowania, jest tylko dużo szumu linii formatu.

Aby móc użyć, wybrano pionową długość 5 print. Nie sądzę, że istnieje sposób na wydruk, który miałby krótszą długość w pionie, deklarując, że funkcje C używają externsłowa kluczowego, stdoutma 6 bajtów długości, write5 bajtów długości, no_main7 bajtów długości (main jest zwykle funkcją;)).

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 , Długość linii: 1, Liczba bajtów: 43

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

Wypróbuj online!

Japt , długość linii 1, 20 bajtów

Na podstawie standardowej wersji Japt Quine firmy ETH .

„
ja
Q

²
„
ja
Q

²

Wypróbuj tutaj!

JavaScript (ES6), długość linii 3, 17 bajtów

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

Czerwona , długość linii: 10, 49 bajtów

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

Wypróbuj online!

W rzeczywistości jest to reine quine

Objaśnienie: Kolor czerwony / Rebol jest moldzgodny ze stylem kodowania polegającym na przesunięciu 4 spacji.

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 bajty, długość linii 1

0
0

Wypróbuj online!

Kopia odpowiedzi Dennisa tutaj (idź do głosu)

Jest to zgodne z naszą obecną definicją właściwego quine, ponieważ pierwsze 0 koduje drugie 0 i odwrotnie.

RProgN 2 , L = 1, B = 15 bajtów

«
Ø
.
`
-
S
`
.

Jest to równoważne z programem:

«Ø.`
-S`
.

Awaria

«najpierw wypycha funkcję reprezentującą niejawnie resztę programu na stos, a następnie kontynuuje wykonywanie. Ø.dołącza pusty ciąg do funkcji, która go uszeregowuje. To zawsze będzie rygorystycznie podobne do programu ekwiwalentnego, ponieważ nowe linie nie będą działać. `\n-Usuwa wszystkie znaki nowej linii z łańcucha, teraz wyglądające jak «Ø.`=S`.. Snastępnie przekształca go w stos pojedynczych znaków i `\n.dołącza do stosu przez nowe linie, zwracając oczekiwany program.

Wypróbuj online!

Niedociążenie , długość linii 1, 20 bajtów

(
:
a
S
S
)
:
a
S
S

Wypróbuj online!

To tylko standardowa quine niedociążenia z dołączonymi znakami nowej linii. Wymaga implementacji takiej jak TIO, która ignoruje nieznane znaki poleceń.

Część w ()jest dosłownym ciągiem umieszczanym na stosie, :powielanym, azawijającym górny wpis stosu w nawiasach i Sdrukowanym.

Perl 5 , 259 bajtów

$
_
=
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
"
}

Wypróbuj online!

Weryfikacja .

JavaScript (ES6 REPL), pełny program, długość linii: 3, liczba bajtów: 31

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

To jest port odpowiedzi @ kamoroso94 na samodzielny pełny program.

Jeśli ktoś znajdzie sposób na usunięcie niektórych bajtów bez dodawania więcej do długości linii, możesz komentować :)

Pip , długość linii 1, 35 bajtów

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

Wypróbuj online!

W oparciu o najkrótszy znany Pip Quine'a, V Y"`V Y`.RPy". Główną trudnością w ściśnięciu go do długości linii 1 jest to RP, że nie można go podzielić na dwie linie. Ale w tym przypadku wszystko RP(repr) robi zawijanie łańcucha w podwójne cudzysłowy, co możemy zrobić bezpośrednio.

Oto wyjaśnienie oparte na wersji poziomej:

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 bajtów

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

Wypróbuj online!

Naprawdę zwykły quine odwrócony bokiem, z dodatkowymi rzeczami do drukowania nowych linii.