Tome uma posição contra longas filas de quine


28

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 critérios de 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.


A regra do desafio inspirado também se aplica aqui? ( " Todas as quebras de linha deve ser significativa quebra de linha que pode ser removido e as linhas adjacentes directamente concatenados sem um impacto sobre a saída, deve ser removido.. ")
Kevin Cruijssen

6
@KevinCruijssen Não, eu queria que esse desafio tivesse um pouco mais de liberdade para incentivar comprimentos de linha mais curtos! Era a única coisa que eu queria mudar no outro desafio!
Dom Hastings

Respostas:


31

Linguagem , comprimento da linha 0, ≈ 1,01 × 10 805 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.


Eu sabia que era inevitável! Eu queria uma pergunta inclusiva. Pergunto-me se alguém pode bater este ...
Dom Hastings

Senhor, esta linguagem é a definição de por código-boliche não é bem-recebida, que é um fresco com certeza ... Não posso acreditar "Olá Mundo" exigiria"about 1.75*10**76 yottabytes in ASCII"
Magia Octopus Urna


Você pode golfe mais de 99% do código usando]++++++++ ++.-->
jimmy23013

28

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


Agradável! Embora realmente não seja um programador de JS, posso adivinhar a essência disso pelo que li sobre o JSFuck, mas eu gostaria de uma explicação especialmente dessa f=linha.
Ørjan Johansen

1
@ ØrjanJohansen Desculpe, eu tenho tentado escrever uma explicação para a coisa toda, mas não está indo muito bem, então vou responder sua pergunta rapidamente: é uma maneira complicada de definir fum único backtick. A linha em si é equivalente a f=atob("12Array")[1]. O outro truque é que, qna verdade, é definido como a letra fna primeira linha, para que na F(...)linha eu possa usá-lo para colocar a letra fna string avaliada, uma vez que a variável fnão está mais definida para essa letra. O a+l+e+r+t+y+a+P+q+P+a+P+q+zé equivalente a "alert(a+f+a+f)".
ETHproductions

Ótimo, agora eu entendo! Você pode mencionar o que 0+{}e 0[E]restringir para obter be m.
Ørjan Johansen

Bom mesmo! Muito menor que a minha tentativa , embora tenhamos usado uma abordagem simar!
Dom Hastings

@DomHastings Enquanto o link nem sequer trabalho ;-)
ETHproductions

15

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.



12

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


2
Tudo o que tenho a dizer é ... • _ •
corsiKa

6

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 !


1
Poupa muito tempo para mudar isso main=putStr$(:"\\\n")=<<s++show s;s="<data>". Experimente online!
Ørjan Johansen

5

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

Não é o comprimento horizontal ?
anatolyg

@anatolyg fixado
Konrad Borowski

O aninhamento de cadeias brutas sem realce de sintaxe torna isso impossível de interpretar. Eu acho cargo fmtque nem ajudaria aqui ...
CAD97

@ CAD97 Se o que você deseja é realçar a sintaxe, o play.rust-lang.org destaca isso corretamente e é por isso que eu o usei em vez do TIO no link "Experimente online".
Konrad Borowski



2

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

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

2

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


2

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!


2

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.


2

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 .


1

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 :)


Observe que isso ainda não produz nada, a menos que você o execute em um REPL. Eu chamaria isso de JavaScript (ES6 REPL)
ETHproductions

oh disparar, maneira de utilizar a consola de cromo ...
Brian H.

1

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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.