ยืนหยัดต่อสู้กับเส้นควินที่มีความยาว


28

หรือ: สร้างควินแนวตั้ง

แรงบันดาลใจจากยืนหยัดต่อสู้กับสายยาว

งานของคุณคือสร้างควินแนวตั้งที่มีความยาวบรรทัดสั้นที่สุดเท่าที่จะทำได้

เกณฑ์การให้คะแนน

ความยาวบรรทัดที่สั้นที่สุด (ไม่รวมบรรทัดใหม่) จะชนะโดยมีเกณฑ์การเป็นไทเบรกเกอร์

ความยาวบรรทัดถูกกำหนดให้เป็นบรรทัดที่ยาวที่สุดในโปรแกรมของคุณยกเว้นอักขระตัวแบ่งบรรทัด

ตัวอย่างเช่น:

$_=
Q.
P

มีความยาวบรรทัด 3 และนับไบต์ 8 ในขณะที่:

Q
$
_
P

มีความยาวบรรทัด 1 และจำนวนไบต์ 7 (สมมติว่าไม่มีการขึ้นบรรทัดใหม่)

กฎระเบียบ

Quines ต้องเป็นไปตามความหมายของชุมชนควิน

ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม


กฎแห่งความท้าทายนี้ได้รับแรงบันดาลใจจากการสมัครที่นี่เช่นกันหรือไม่? ("การแบ่งบรรทัดทั้งหมดต้องมีความหมายการขึ้นบรรทัดใหม่ที่สามารถลบออกได้และการเชื่อมโยงบรรทัดที่ต่อกันโดยตรงโดยไม่มีผลกระทบกับเอาต์พุตจะต้องลบออก ")
Kevin Cruijssen

6
@KevinCruijssen ไม่ฉันต้องการความท้าทายนี้เพื่อให้มีอิสระมากขึ้นในการส่งเสริมความยาวบรรทัดที่สั้นกว่า! มันเป็นสิ่งหนึ่งที่ฉันต้องการเปลี่ยนแปลงในการท้าทายอื่น ๆ !
Dom Hastings

คำตอบ:


31

Lenguageความยาวบรรทัด 0, ≈ 1.01 × 10 805ไบต์

รหัสแหล่งที่มาประกอบด้วย

10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943

linefeeds ซึ่งเข้ารหัสโปรแกรม brainfuck ที่ตามมา

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

ซอร์สโค้ดส่วนใหญ่นั้นเหมือนกับQueng Lenguage ที่อ่อนนุ่มด้วยรังสีของ @ jimmy23013ลบ.ปลายในตอนท้ายด้วยการ++++++++++.[-]แทนที่.การพิมพ์บรรทัดฟีดแทนไบต์ว่างและการเปลี่ยนแปลงที่สอดคล้องกับส่วนข้อมูลในบรรทัดที่ 1


ฉันรู้ว่ามันหลีกเลี่ยงไม่ได้! ฉันต้องการคำถามแบบรวม ผมสงสัยว่าถ้าใครสามารถเอาชนะนี้ ...
Dom เฮสติ้งส์

ท่านลอร์ดภาษานี้เป็นคำนิยามว่าทำไมการโยนรหัสไม่ได้รับการตอบรับที่ดีอย่างแน่นอน ... ไม่อยากจะเชื่อว่า "Hello World" ต้องใช้"about 1.75*10**76 yottabytes in ASCII"
Magic Octopus Urn

ผมเคยถามเกี่ยวกับเมตาเกี่ยวกับการยอมรับคำตอบทางทฤษฎี
Dom Hastings

คุณสามารถตีกอล์ฟได้มากกว่า 99% ของรหัสโดยใช้]++++++++ ++.-->
jimmy23013

28

JavaScript, ความยาวบรรทัด 1, 960 956 928 ไบต์


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

รุ่นที่อ่านได้มากขึ้นซึ่งเกิดขึ้นเป็นควิน (ลบ newlines ภายนอก):


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

คำอธิบาย

ต๊าย มานั่งที่นี่เพราะนี่จะเป็นการเดินทางที่ทรยศ ...

ฉันใช้เวลานานในการพยายามที่จะคิดออกว่าจะแก้ปัญหาความท้าทายนี้มีความยาว 1 ตัวไม่มีอิน (โดยตรงอยู่แล้ว) คำหลักหรือแม้กระทั่งลูกศรฟังก์ชั่นก่อนที่จะทราบว่ามันเป็นไปได้อย่างง่ายดายด้วยJSF ***ซึ่งสามารถ ประเมินโค้ด JavaScript ใด ๆ ในขณะที่หลีกเลี่ยงโทเค็นหลายไบต์ แต่โซลูชัน JSF อาจมีความยาวหลายพันไบต์ได้อย่างง่ายดายหากไม่นับหรือนับแสน ขอบคุณเราไม่ จำกัด เพียงแค่()[]+!เรามี ASCII ทั้งหมดในการกำจัดของเรา!

ฉันตัดสินใจที่จะเริ่มต้นด้วยการตีองค์ประกอบสำคัญของ JSF - ตัวละครที่สามารถสร้างเป็นสตริงเพื่อ "ปลดล็อกคุณสมบัติเพิ่มเติม" เพื่อพูด เราไม่สามารถใช้สตริงโดยตรงเพื่อรับอักขระเนื่องจากต้องใช้ความยาว 3 บรรทัดดังนั้นเราจึงขโมยเคล็ดลับจาก JSF รับตัวอักษรสองสามตัวจากตัวอักษรที่สามารถสร้างด้วยโทเค็นไบต์เดียว:

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

จากสิ่งเหล่านี้เราสามารถขยายออกไปด้านนอกเริ่มต้นด้วย[].findซึ่งเป็นฟังก์ชั่นวัตถุ แปลงนี้เพื่อสตริงfunction find() { ...จะช่วยให้เราเข้าถึงc, oพื้นที่ ( _) และวงเล็บ ( yและz) บางทีอาจจะมากกว่าที่สำคัญตอนนี้เรามีการเข้าถึงของconstructorผู้Functionฟังก์ชั่นซึ่งเป็น inceptional มันอาจจะทำให้เรามีความสามารถในการรันโค้ดโดยการสร้างสตริงผ่านไปFunction()แล้วเรียกฟังก์ชั่นที่สร้างขึ้น

ฉันควรจะพูดถึงวิธีการโดยรวมที่ใช้โดยโปรแกรมเอง ในฐานะของปี 2015 JavaScript มีคุณสมบัติเย็นนี้มันเรียกว่า " แท็กแม่ " ซึ่งไม่เพียง แต่ช่วยให้การขึ้นบรรทัดใหม่ไม่ใช้ Escape ในสาย แต่ยังช่วยให้เราเรียกใช้ฟังก์ชันกับสตริงตัวอักษรโดยตรง (ในทาง; myFunc`abc`;เทียบเท่าประมาณไปmyFunc(["abc"])) ถ้าเราใส่ function call เป็นสิ่งสุดท้ายในโปรแกรมโครงสร้างทั่วไปจะมีลักษณะดังนี้:

code;func`code;func`

สิ่งที่funcต้องทำคือเอาท์พุทอาร์กิวเมนต์ของมันตามด้วย backtick จากนั้นอาร์กิวเมนต์ของมันอีกครั้งและแบ็คทิกที่สอง สมมติว่าเรามีข้อโต้แย้งในaและ backtick ที่เก็บไว้ในเราสามารถบรรลุนี้มีรหัสf alert(a+f+a+f)อย่างไรก็ตามในขณะนี้เราหายไป+และ backtick ตัวเอง +(เก็บไว้ในP) ไม่ยาก เราขโมยเคล็ดลับอื่นจาก JSF อาคารสตริงแปลงเป็นตัวเลขแล้วกลับไปสตริงให้1e23"1e+23"

การรับ backtick นั้นซับซ้อนกว่าเล็กน้อย ตอนแรกฉันพยายามได้String.fromCharCodeมา แต่การค้นหาCกลายเป็นเรื่องยาก โชคดีที่atobมันง่ายพอที่จะได้รับ ( Function("return atob")(); bสร้างขึ้นจาก0+{}ซึ่งให้[object Object]) และสามารถให้ถ่าน ASCII ใด ๆ หากพบว่ามีสายเวทที่เหมาะสม สคริปต์สั้นให้ฉัน12Aเป็นหนึ่งในตัวเลือกที่สามารถอำนวยความสะดวกที่จะพบใน12Array(บิตสั้นเพื่อสร้างขอบคุณ[].constructor[n+a+m+e]; mพบใน0 .constructor+0: "function Number() { ...")

ในที่สุดเราก็รวมทุกอย่างเข้าด้วยกัน เรากำหนด backtick ให้กับตัวแปรfแต่เนื่องจากเราไม่สามารถใช้โดยตรงในสตริงฟังก์ชั่นเราจึงตั้งค่าตัวแปรqให้กับตัวอักษรfและใช้แทน นี้จะทำให้สตริงสุดท้ายของเราหรือa+l+e+r+t+y+a+P+q+P+a+P+q+z "alert(a+f+a+f)"จากนั้นเราป้อนสิ่งนี้เพื่อFunction()ป้อนรหัสที่เสร็จแล้วของเราไปยังผลลัพธ์และ voila เรามี JavaScript quine ที่มีอักขระไม่เกินหนึ่งตัวต่อบรรทัด!


หัวของฉันรู้สึกแย่ในขณะนี้ดังนั้นโปรดสอบถามเกี่ยวกับข้อผิดพลาดใด ๆ ที่ฉันทำหรือสิ่งที่ฉันพลาดในคำอธิบายนี้และฉันจะกลับไปหาคุณหลังจากที่ฉันได้พักผ่อน ...


Nice! Although really not a JS programmer, I can guess the gist of this from what I've read about JSFuck, but I'd like an explanation especially of that f= line.
Ørjan Johansen

1
@ØrjanJohansen Sorry, I've been trying to write an explanation for the whole thing, but it's not going very well so I'll just answer your question quickly: it's a convoluted way to set f to a single backtick. The line itself is equivalent to f=atob("12Array")[1]. The other trick is that q is actually set to the letter f in the first line, so that in the F(...) line, I can use it to put the letter f in the evaluated string, since variable f is no longer set to that letter. The a+l+e+r+t+y+a+P+q+P+a+P+q+z is equivalent to "alert(a+f+a+f)".
ETHproductions

Great, now I understand it! You might mention what 0+{} and 0[E] stringify to in order to get b and m.
Ørjan Johansen

Nice indeed! Much smaller than my attempt, although we used a simar approach!
Dom Hastings

@DomHastings So long the link doesn't even work ;-)
ETHproductions

15

Haskell, line length 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':
'=':
[]}

Try it online! I'm not aware of a way around putStr, thus the line length of 6. The outer curly braces allow to get rid of the otherwerwise required indention after a newline within a single declaration.



12

CJam, line length 1, 16 13 bytes

"
_
p
"

_
p

Try it online!

It's a small miracle that inserting newlines into the standard quine {"_~"}_~ even shorter standard quine "_p"␊_p does the right thing. (Thanks, Martin!) The trailing newline is necessary.

Explanation (with • as 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.

On termination, what's left on the stack is printed (•_•p•), yielding total output "•_•p•"••_•p•.


2
All I have to say is ... •_•
corsiKa

6

Haskell + CPP, line length 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\
=\
"\

Try it online! Using the flag -CPP which enables the C pre-processor allows us to use a backslash at the end of a line to continue it on the next line.

The actual code is main=putStr$(:"\\\n")=<<s++show s;s="<data>".

Edit: A casual -468 bytes thanks to Ørjan Johansen!


1
It saves a lot of escaping to change that to main=putStr$(:"\\\n")=<<s++show s;s="<data>". Try it online!
Ørjan Johansen

5

Rust, line length: 5, bytes: 301 299

Try it online

Despite how it looks, this isn't an esoteric programming language, there is just a lot of format line noise.

Vertical length of 5 was chosen to be able to use print. I don't think there is a way to print that would have shorter vertical length, declaring C functions uses extern keyword, stdout is 6 bytes long, write is 5 bytes long, no_main is 7 bytes long (main is usually a function ;)).

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,
'}'
)}

Isn't it horizontal length?
anatolyg

@anatolyg fixed
Konrad Borowski

Raw string nesting without syntax highlighting makes this impossible to interpret. I don't think cargo fmt would even help here...
CAD97

@CAD97 If what you want is syntax highlighting, play.rust-lang.org highlights this correctly which is why I used it instead of TIO for "Try it online" link.
Konrad Borowski




2

Red, line-length: 10, 49 bytes

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

Try it online!

This in fact is a Rebol quine

Explanation: Red/Rebol's mold follows the coding style of putting 4 spaces offset.

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


2

RProgN 2, L = 1, B = 15 bytes

«
Ø
.
`
-
S
`
.

This is equivilent to the program:

«Ø.`
-S`
.

Breakdown

« first pushes a function representing implicitly the rest of the program to the stack, and then continues execution. Ø. appends an empty string to the function, which stringifies it. This will always stringify like the equivilent program, due to newlines being no-ops. `\n- Removes all newlines from the string, now looking like «Ø.`=S`.. S then converts it to a stack of single characters, and `\n. joins the stack by newlines, returning the expected program.

Try it online!


2

Underload, line length 1, 20 bytes

(
:
a
S
S
)
:
a
S
S

Try it online!

This is just the standard Underload quine with newlines appended. Requires an implementation like the TIO one which ignores unknown command characters.

The part in () is a string literal put on the stack, : duplicates it, a wraps the top stack entry in parentheses, and S prints.



1

Javascript (ES6 REPL), full-program, line-length: 3, byte-count: 31

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

This is a port of @kamoroso94's answer to a self-contained full program.

If anybody finds a way to strip off some bytes without adding more to the line-length feel free to comment :)


Note that this still doesn't actually output anything, unless you run it in an REPL. I would call it JavaScript (ES6 REPL)
ETHproductions

oh shoot, way to used to chrome's console...
Brian H.

1

Pip, line length 1, 35 bytes


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

Try it online!

Based on the shortest known Pip quine, V Y"`V Y`.RPy". The main difficulty in squishing it to line length 1 is RP, which can't be split over two lines. But in this case, all RP (repr) does is wrap the string in double quotes, which we can do directly.

Here's an explanation based on a horizontal 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

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.