ou: Construisez un quine vertical

^{Inspiré par Prenez position contre les longues lignes .}

Votre tâche consiste à créer un quine vertical avec une longueur de ligne aussi courte que possible.

Notation

La longueur de ligne la plus courte (hors nouvelles lignes) gagne, avec des critères de code-golf comme briseur d'égalité.

La longueur de ligne est déterminée comme la ligne la plus longue de votre programme à l'exclusion du caractère de saut de ligne.

Par exemple:

$_=
Q.
P

a une longueur de ligne de 3 et un nombre d'octets de 8, tandis que:

Q
$
_
P

A une longueur de ligne de 1 et un nombre d'octets de 7 (en supposant qu'il n'y ait pas de nouvelle ligne de fin).

Règles

Les quines doivent répondre à la définition communautaire d'une quine .

Les failles standard sont interdites.

Langue , longueur de ligne 0, ≈ 1,01 × 10 ⁸⁰⁵ octets

Le code source se compose de

10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943

linefeeds, qui code le programme brainfuck qui suit.

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

Le code source est en grande partie identique au quine Lenguage adouci par rayonnement de @ jimmy23013 , moins le .à la fin, avec ++++++++++.[-]remplacement .pour imprimer les sauts de ligne au lieu d'octets nuls, et les modifications correspondantes apportées à la section des données sur la ligne 1.

JavaScript, longueur de ligne 1, 960 956 928 octets

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

Version plus lisible qui s'avère également être une quine (les nouvelles lignes superflues ont été supprimées):

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

Explication

Ouf. Installez-vous pour une balade ici, parce que ça va être un voyage perfide ...

J'ai passé beaucoup de temps à essayer de comprendre comment résoudre ce défi avec la longueur 1 - pas de fonctions intégrées (directement, de toute façon), de mots clés ou même de fonctions fléchées - avant de réaliser que c'est facilement possible avec JSF *** , qui peut évaluer tout code JavaScript tout en évitant les jetons multi-octets. Mais une solution JSF aurait facilement des milliers d'octets, sinon des dizaines ou des centaines de milliers. Heureusement, nous ne sommes pas limités à seulement ()[]+!- nous avons tout ASCII à notre disposition!

J'ai décidé de commencer par jouer au golf sur les blocs de construction essentiels de JSF - les personnages qui peuvent être construits en chaînes pour «débloquer plus de fonctionnalités», pour ainsi dire. Nous ne pouvons pas utiliser directement des chaînes pour obtenir des caractères, car cela nécessiterait des lignes de longueur 3. Ainsi, nous volons une astuce à JSF, obtenant quelques caractères des littéraux qui peuvent être construits avec des jetons à un octet:

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

De ceux-ci, nous pouvons développer vers l'extérieur, en commençant par [].find, qui est un objet Function. La conversion de ce à une chaîne function find() { ...nous donne accès à c, o, l' espace ( _), et les parenthèses ( yet z). Peut-être plus important encore , nous avons maintenant accès à son constructor, la Functionfonction qui, inceptional que cela puisse paraître, nous donne la possibilité d'exécuter du code par la construction d' une chaîne, en passant à Function(), puis d' appeler la fonction générée.

Je devrais probablement mentionner la méthode globale utilisée par le programme lui-même. À partir de 2015, JavaScript a cette fonctionnalité vraiment cool appelée « modèles balisés », qui permet non seulement des sauts de ligne sans échappement dans les chaînes, mais nous permet également d'appeler directement une fonction avec un littéral de chaîne (en quelque sorte; myFunc`abc`;est à peu près équivalent à myFunc(["abc"])). Si nous plaçons l'appel de fonction comme dernière chose dans le programme, la structure générale ressemblera à ceci:

code;func`code;func`

Il funcsuffit alors de sortir son argument, suivi d'un backtick, puis de nouveau son argument, et d'un second backtick. En supposant que nous ayons l'argument aet un backtick stockés dans f, nous pouvons accomplir cela avec le code alert(a+f+a+f). Cependant, pour le moment, nous +manquons et le backtick lui-même. +(stocké dans P) n'est pas difficile; nous volons une autre astuce à JSF, la construction de la chaîne 1e23, la conversion en un nombre, puis de nouveau en une chaîne, donnant "1e+23".

Obtenir un backtick est un peu plus compliqué. Au début, j'ai essayé de l'obtenir String.fromCharCode, mais trouver un Cavéré s'est avéré presque aussi difficile. Heureusement, atobest assez facile à obtenir ( Function("return atob")(); best généré à partir de 0+{}, ce qui donne [object Object]) et peut donner n'importe quel caractère ASCII, si une chaîne magique appropriée est trouvée. Un court script m'a donné 12Acomme l'une des options, qui peut être facilement trouvée dans 12Array(un peu plus court à générer, grâce à [].constructor[n+a+m+e]; mse trouve dans 0 .constructor+0:) "function Number() { ...".

Enfin, nous collons tout ensemble. Nous attribuons le backtick à la variable f, mais comme nous ne pouvons pas l'utiliser directement dans la chaîne de fonction, nous définissons plutôt la variable qsur la lettre fet nous l'utilisons à la place. Cela rend notre chaîne finale a+l+e+r+t+y+a+P+q+P+a+P+q+z, ou "alert(a+f+a+f)". Nous alimentons ensuite ceci Function(), alimentons notre code fini au résultat, et le tour est joué, nous avons un quine JavaScript avec pas plus d'un caractère par ligne!

Ma tête est horrible pour le moment, alors s'il vous plaît, renseignez-vous sur les erreurs que j'ai faites ou les choses que j'ai manquées dans cette explication, et je vous répondrai après un peu de repos ...

Haskell , longueur de ligne 6, 400 343 336 octets

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

Essayez-le en ligne! Je ne suis pas au courant d'un moyen de contourner putStr, donc la longueur de ligne de 6. Les accolades externes permettent de se débarrasser de l'indentation requise dans le cas contraire après une nouvelle ligne dans une seule déclaration.

> <> , 22 octets, longueur de ligne 1

/
v
o
a
o
^
}
-
d
:
"

Essayez-le en ligne!

-6 octets grâce à Emigna .

CJam , longueur de ligne 1, 16 13 octets

"
_
p
"

_
p

Essayez-le en ligne!

C'est un petit miracle que l'insertion de nouvelles lignes dans le quine standard,{"_~"}_~ même un quine standard plus court, "_p"␊_pfasse la bonne chose. (Merci, Martin!) La nouvelle ligne de fin est nécessaire.

Explication (avec • comme nouvelle ligne)

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

À la fin, ce qui reste sur la pile est imprimé (•_•p• ), ce qui donne une sortie totale "•_•p•"••_•p•.

Haskell + CPP, longueur de ligne 2, 705 237 octets

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

Essayez-le en ligne!L'utilisation de l'indicateur -CPPqui active le pré-processeur C nous permet d'utiliser une barre oblique inversée à la fin d'une ligne pour continuer sur la ligne suivante.

Le code réel est main=putStr$(:"\\\n")=<<s++show s;s="<data>" .

Edit: Un casual -468 octets grâce à Ørjan Johansen !

Rouille, longueur de ligne: 5, octets: 301 299

Essayez-le en ligne

Malgré son apparence, ce n'est pas un langage de programmation ésotérique, il y a juste beaucoup de bruit de ligne de format.

La longueur verticale de 5 a été choisie pour pouvoir être utilisée print. Je ne pense pas qu'il existe un moyen d'imprimer qui aurait une longueur verticale plus courte, en déclarant que les fonctions C utilisent un externmot clé, stdoutest de 6 octets de long, write5 octets de long, no_main7 octets de long (main est généralement une fonction;)).

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 , Longueur de ligne: 1, Nombre d'octets: 43

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

Essayez-le en ligne!

Japt , longueur de ligne 1, 20 octets

Basé sur la norme Japt quine par ETHproductions .

"
je
Q

²
"
je
Q

²

Essayez-le ici!

JavaScript (ES6), longueur de ligne 3, 17 octets

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

Rouge , longueur de ligne: 10, 49 octets

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

Essayez-le en ligne!

Ceci est en fait un Rebol quine

Explication: Red / Rebol moldsuit le style de codage consistant à mettre 4 espaces décalés.

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 octets, longueur de ligne 1

0
0

Essayez-le en ligne!

Une copie de la réponse de Dennis ici (allez le voter aussi)

Ceci est conforme à notre définition actuelle d'un quine approprié, car le premier 0 code le second 0 et vice-versa.

RProgN 2 , L = 1, B = 15 octets

«
Ø
.
`
-
S
`
.

Cela équivaut au programme:

«Ø.`
-S`
.

Panne

«envoie d'abord une fonction représentant implicitement le reste du programme à la pile, puis poursuit l'exécution. Ø.ajoute une chaîne vide à la fonction, qui la chaîne. Cela se stringifiera toujours comme le programme équivalent, car les sauts de ligne ne sont pas opérationnels. `\n-Supprime toutes les nouvelles lignes de la chaîne, ressemblant maintenant à «Ø.`=S`.. Spuis le convertit en une pile de caractères uniques et `\n.rejoint la pile par des sauts de ligne, renvoyant le programme attendu.

Essayez-le en ligne!

Sous-charge , longueur de ligne 1, 20 octets

(
:
a
S
S
)
:
a
S
S

Essayez-le en ligne!

Ceci est juste le quine standard de sous-charge avec des nouvelles lignes ajoutées. Nécessite une implémentation comme celle de TIO qui ignore les caractères de commande inconnus.

La partie dans ()est un littéral de chaîne placé sur la pile, la :duplique, aenveloppe l'entrée de pile supérieure entre parenthèses et Simprime.

Perl 5 , 259 octets

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

Essayez-le en ligne!

Vérification .

Javascript (ES6 REPL), programme complet, longueur de ligne: 3, nombre d'octets: 31

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

Il s'agit d'un portage de la réponse de @ kamoroso94 à un programme complet autonome.

Si quelqu'un trouve un moyen de supprimer certains octets sans ajouter plus à la longueur de ligne, n'hésitez pas à commenter :)

Pip , longueur de ligne 1, 35 octets

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

Essayez-le en ligne!

Basé sur le Quine Pip le plus court connu, V Y"`V Y`.RPy". La principale difficulté à l'écraser à la longueur de ligne 1 est RP, qui ne peut pas être divisée en deux lignes. Mais dans ce cas, tousRP (repr) fait est de mettre la chaîne entre guillemets, ce que nous pouvons faire directement.

Voici une explication basée sur une version horizontale:

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 octets

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

Essayez-le en ligne!

Vraiment juste un quine normal tourné de côté, avec quelques trucs supplémentaires pour imprimer des nouvelles lignes.