ou: Construa uma coluna vertical

^{Inspirado por Tome uma posição contra longas filas .}

Sua tarefa é construir um quine vertical com o menor comprimento possível de linha.

Pontuação

O menor comprimento da linha (excluindo novas linhas) vence, com os critérios de código de golfe como desempate.

O comprimento da linha é determinado como a linha mais longa do seu programa, excluindo o caractere de quebra de linha.

Por exemplo:

$_=
Q.
P

tem um comprimento de linha de 3 e uma contagem de bytes de 8, enquanto:

Q
$
_
P

Tem um comprimento de linha de 1 e uma contagem de bytes de 7 (assumindo que não há nova linha à direita).

Regras

Quines devem atender à definição da comunidade de um quine .

As brechas padrão são proibidas.

Linguagem , comprimento da linha 0, ≈ 1,01 × 10 ⁸⁰⁵ bytes

O código fonte consiste em

10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943

linefeeds, que codifica o programa brainfuck a seguir.

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

O código-fonte é quase idêntico ao Lenguage suavizado por radiação de jimmy23013 , menos o .no final, com a ++++++++++.[-]substituição .para imprimir feeds de linha em vez de bytes nulos e as alterações correspondentes na seção de dados na linha 1.

JavaScript, comprimento da linha 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
)
`

Versão mais legível, que também é um quine (novas linhas externas removidas):

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

Explicação

Ufa. Aceite uma carona aqui, porque esta será uma jornada traiçoeira ...

Passei muito tempo tentando descobrir como resolver esse desafio com o comprimento 1 - sem incorporar (diretamente, de qualquer maneira), palavras-chave ou até funções de seta - antes de perceber que isso é facilmente possível com o JSF *** , que pode avalie qualquer código JavaScript e evite tokens de vários bytes. Mas uma solução JSF seria facilmente de milhares de bytes, se não dezenas ou centenas de milhares. Felizmente, não estamos limitados a apenas - ()[]+!temos todos os ASCII à nossa disposição!

Decidi começar jogando os elementos essenciais do JSF - os personagens que podem ser construídos em strings para "desbloquear mais recursos", por assim dizer. Não podemos usar strings diretamente para obter caracteres, pois isso exigiria linhas de comprimento 3. Então, em vez disso, roubamos um truque do JSF, obtendo alguns caracteres de literais que podem ser construídos com tokens de byte único:

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

A partir disso, podemos expandir para fora, começando com [].find, que é um objeto de Função. Convertendo isso para uma seqüência function find() { ...nos dá acesso a c, o, espaço ( _) e parênteses ( ye z). Talvez mais importante, agora temos acesso à sua constructor, a Functionfunção-que, inceptional que possa parecer, nos dá a capacidade de executar código através da construção de uma corda, passando-a para Function(), em seguida, chamar a função gerada.

Eu provavelmente mencionaria o método geral usado pelo próprio programa. A partir de 2015, o JavaScript tem esse recurso muito legal chamado " modelos marcados " , que não apenas permite novas linhas sem escape em cadeias de caracteres, mas também permite chamar uma função com uma literal de cadeia diretamente (de certa forma; myFunc`abc`;é aproximadamente equivalente a myFunc(["abc"])). Se colocarmos a chamada de função como a última coisa no programa, a estrutura geral ficará assim:

code;func`code;func`

Tudo o que funcprecisa fazer é emitir seu argumento, seguido por um backtick, depois seu argumento novamente e um segundo backtick. Supondo que temos o argumento ae um backtick armazenados f, podemos fazer isso com o código alert(a+f+a+f). No entanto, no momento, estamos perdendo +e o próprio bastão. +(armazenado em P) não é difícil; roubamos outro truque do JSF, construindo a string 1e23, convertendo em um número, depois voltando a uma string, dando "1e+23".

Conseguir um backtick é um pouco mais complicado. No começo, tentei obter String.fromCharCode, mas encontrar um Cresultado quase tão difícil. Felizmente, atobé fácil de obter ( Function("return atob")(); bé gerado a partir de 0+{}, o que fornece [object Object]) e pode fornecer qualquer caractere ASCII, se uma string mágica apropriada for encontrada. Um pequeno script me deu 12Acomo uma das opções, que podem ser convenientemente encontrados em 12Array(um pouco mais curto para gerar, graças a [].constructor[n+a+m+e]; mé encontrado em 0 .constructor+0: "function Number() { ...").

Finalmente, juntamos tudo. Atribuímos o backtick à variável f, mas, como não podemos usá-lo diretamente na cadeia de funções, definimos a variável qcomo letra fe, em vez disso, a usamos. Isso torna nossa string final a+l+e+r+t+y+a+P+q+P+a+P+q+z, ou "alert(a+f+a+f)". Em seguida, alimentamos isso Function(), alimentamos o código final para o resultado e, voila, temos um código JavaScript com não mais que um caractere por linha!

Minha cabeça está péssima no momento, por isso, pergunte sobre os erros que cometi ou sobre as coisas que perdi nesta explicação, e voltarei a responder depois de descansar um pouco ...

Haskell , comprimento da linha 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':
'=':
[]}

Experimente online! Não tenho conhecimento de uma maneira de contornar putStr, portanto, o comprimento da linha de 6. Os chavetas externas permitem livrar-se da recuo necessária de outra maneira após uma nova linha em uma única declaração.

> <> , 22 bytes, comprimento de linha 1

/
v
o
a
o
^
}
-
d
:
"

Experimente online!

-6 bytes graças a Emigna .

CJam , comprimento da linha 1, 16 13 bytes

"
_
p
"

_
p

Experimente online!

É um pequeno milagre que a inserção de novas linhas no quine padrão{"_~"}_~ ainda mais curto "_p"␊_pfaça o que é certo. (Obrigado, Martin!) A nova linha à direita é necessária.

Explicação (com • como nova linha)

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

Na terminação, o que resta na pilha é impresso ( •_•p•), produzindo uma saída total "•_•p•"••_•p•.

Haskell + CPP, comprimento da linha 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\
=\
"\

Experimente online! O uso do sinalizador -CPPque habilita o pré-processador C nos permite usar uma barra invertida no final de uma linha para continuar na próxima linha.

O código real é main=putStr$(:"\\\n")=<<s++show s;s="<data>".

Edit: Um casual -468 bytes graças a Ørjan Johansen !

Ferrugem, comprimento da linha: 5, bytes: 301 299

Experimente online

Apesar da aparência, essa não é uma linguagem de programação esotérica, há muito ruído na linha de formato.

O comprimento vertical de 5 foi escolhido para poder usar print. Eu não acho que exista uma maneira de imprimir que tenha menor comprimento vertical, declarando que as funções C usam a externpalavra-chave, stdouttem 6 bytes de comprimento, write5 bytes de comprimento, no_main7 bytes de comprimento (main é geralmente uma função;)).

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 , Comprimento da linha: 1, Contagem de bytes: 43

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

Experimente online!

Japt , comprimento da linha 1, 20 bytes

Baseado no padrão japonês da ETHproductions .

"
Eu
Q

²
"
Eu
Q

²

Experimente aqui!

JavaScript (ES6), comprimento da linha 3, 17 bytes

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

Vermelho , comprimento de linha: 10, 49 bytes

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

Experimente online!

Este é de fato um Rine Quine

Explicação: O vermelho / Rebol moldsegue o estilo de codificação de colocar 4 espaços deslocados.

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, comprimento de linha 1

0
0

Experimente online!

Uma cópia da resposta de Dennis aqui (faça um voto positivo também)

Isso está de acordo com nossa definição atual de quine adequada, pois o primeiro 0 codifica o segundo 0 e vice-versa.

RProgN 2 , L = 1, B = 15 bytes

«
Ø
.
`
-
S
`
.

Isso é equivalente ao programa:

«Ø.`
-S`
.

Demolir

«primeiro envia uma função que representa implicitamente o restante do programa para a pilha e continua a execução. Ø.anexa uma string vazia à função, que a especifica. Isso sempre será estrito como o programa equivalente, devido às novas linhas serem não operacionais. `\n-Remove todas as novas linhas da string, agora parecendo «Ø.`=S`.. Sem seguida, converte-o em uma pilha de caracteres únicos e `\n.junta-se à pilha por novas linhas, retornando o programa esperado.

Experimente online!

Subcarga , comprimento da linha 1, 20 bytes

(
:
a
S
S
)
:
a
S
S

Experimente online!

Este é apenas o quine padrão do Underload com as novas linhas anexadas. Requer uma implementação como a do TIO, que ignora caracteres de comando desconhecidos.

A parte in ()é uma string literal colocada na pilha, :duplica-a, coloca aa entrada superior da pilha entre parênteses e Simprime.

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
"
}

Experimente online!

Verificação .

Javascript (ES6 REPL), programa completo, comprimento de linha: 3, contagem de bytes: 31

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

Esta é uma porta da resposta do @ kamoroso94 para um programa completo independente.

Se alguém encontrar uma maneira de remover alguns bytes sem adicionar mais ao comprimento da linha, fique à vontade para comentar :)

Pip , comprimento da linha 1, 35 bytes

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

Experimente online!

Com base no pip quine mais curto conhecido V Y"`V Y`.RPy",. A principal dificuldade em comprimir o comprimento da linha 1 é RPque não pode ser dividido em duas linhas. Mas neste caso, tudo o que RP(repr) faz é colocar a cadeia entre aspas duplas, o que podemos fazer diretamente.

Aqui está uma explicação baseada em uma versão horizontal:

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
#
:
,
^
$
"

Experimente online!

Realmente, apenas um quine normal virou de lado, com algumas coisas extras para imprimir novas linhas.