La tâche est un défi quine assez simple avec une torsion, vous devez sortir votre code source sous la forme d'une pyramide. La forme d'une pyramide est définie ci-dessous:

       1
      234
     56789
    ABCDEFG
   HIJKLMNOP
  QRSTUVWXYZa
 bcdefghijklmn
......etc......

La principale limitation de ce défi est que votre quine doit contenir exactement suffisamment d'octets pour ne pas obstruer le motif de la pyramide. Par exemple, les longueurs de programme suivantes fonctionneraient:

1-byter: 1st layer of the pyramid (not allowed by definition of a quine).
4-byter: 1st and 2nd layers of the pyramid.
9-byter: 1st, 2nd and 3rd layers of the pyramid.
etc...

Donc, si votre programme était:

QWERTY

Ce ne serait pas valable, car cela s'arrangerait comme:

  Q
 WER
TY

Cependant, si votre programme était QWERTYUIO, ce serait bien:

  Q
 WER
TYUIO

Règles

• Les failles standard sont évidemment interdites, pas de lecture de votre propre source.
• La pyramide doit être centrée, les caractères de fin sont autorisés, mais pas obligatoires.
  • De plus, n'importe quel caractère peut être utilisé pour centrer la pyramide, ce n'est pas obligatoire (char)32.
• Votre quine doit pouvoir prendre la forme d'une pyramide.
  • Il doit conserver la commande d'origine de votre code source.
  • Votre code source ne doit PAS contenir le caractère utilisé pour formater la pyramide.
  • EG si votre code source contient un espace, vous aurez besoin d'un autre caractère pour le format.
• Vous pouvez utiliser des commentaires dans votre quine pour "pad" à la bonne taille.
  • Évidemment, ceux-ci doivent être sortis dans le cadre du quine.
• Si le programme contient des sauts de ligne / tabulations, ils ne font pas partie du quine et doivent être omis dans la sortie.
• La forme est comptée en caractères, pas en octets; si la forme est mal formée, vous ne le faites pas correctement.

Le score le plus bas possible ici devrait être de 4.

05AB1E , 36 octets

"34çs«DJā·<£õK.cJ?"34çs«DJā·<£õK.cJ?

Essayez-le en ligne!

Si trailing characters are allowedsignifie également à la fin de la sortie, 0"D34çýā·<£.c"D34çýā·<£.cest une couche plus courte à 25 octets.

Java 11, 324 256 227 octets

v->{var s="v->{vars=%c%s%1$c;for(inti=0;;)System.out.printf(%1$c%%%1$c+(15+i)+%1$cs%%n%1$c,s.format(s,34,s).substring(i*i,++i*i));}///";for(int i=0;;)System.out.printf("%"+(15+i)+"s%n",s.format(s,34,s).substring(i*i,++i*i));}//

-29 octets grâce à @JoKing .

Sorties avec espaces de tête pour créer le triangle. (Notez que les espaces entre var set int isont des tabulations, pas des espaces.)

Essayez-le en ligne.

Explication:

quine -part:

• var s contient la chaîne de code source non formatée
• %s est utilisé pour mettre cette chaîne en elle-même avec s.format(...)
• %c, %1$cEt 34sont utilisés pour formater les guillemets doubles ( ")
• %% est utilisé pour formater le %
• s.format(s,34,s) met tout cela ensemble

Partie défi:

for(int i=0;;)         // Loop `i` indefinitely upwards from 0
  System.out.printf(   //  Print with format:
    "%"+(15+i)+"s      //   Add leading spaces to make the line length size 15+`i`
                 %n",  //   And include a trailing newline
    s.format(s,34,s).substring(
                       //   And append a substring of the source code-String
       i*i,            //    From index `i` squared
       ++i*i));}       //    To index `i+1` squared

Ce qui s'arrête avec une java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226erreur pour la String#substring(int,int)méthode, l'itération après avoir imprimé le résultat ( ce qui est bien selon la méta ).

Python 2 , 81 octets

s='n=0;\nprint(8-n)*chr(32)+("s=%r;exec(s*9)"%s)[n*n:][:n-~n];n+=1;#JK';exec(s*9)

Essayez-le en ligne!

Un quine eval qui utilise des espaces comme caractère de remplissage.

Perl 6 , 67 octets

<say("<$_>~~.EVAL".substr($!++²,$!*2-1).indent(8-$!))xx⁸>~~.EVAL

Essayez-le en ligne!

J'ai utilisé quelques caractères Unicode afin d'extraire cette couche supplémentaire. Sorties utilisant des espaces:

       <
      say
     ("<$_
    >~~.EVA
   L".substr
  ($!++²,$!*2
 -1).indent(8-
$!))xx⁸>~~.EVAL

Explication:

<say("<$_>~~.EVAL"                                  )   >~~.EVAL   # Normal quine
                  .substr($!++²,$!*2-1)              xx⁸  # Split into layered substrings
                                       .indent(8-$!)      # And indent each one

Python 2 , 169 octets

Utilise 0pour formater la pyramide.

s='s=%r;k=s%%s;print"\\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for n in range(13))#######################';k=s%s;print"\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for n in range(13))

Essayez-le en ligne!

Python 2 , 147 octets

Cela utilise la règle Si le programme contient des sauts de ligne / tabulations, ils ne font pas partie du quine et doivent être omis dans la sortie.

s='s=%r;k=s%%s;print"\\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]forninrange(13))##';k=s%s;print"\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for	n	in	range(13))##

Essayez-le en ligne!

Gol> <> , 36 octets

":P}r6&56F:M}F0ss|&:P&Roao{|;Nooooo!

Essayez-le en ligne!

une version encore plus jeune, 36 octets

":P}r6&56F:M}R` &:P&Fo|ao{|;Noooooo!

Je me sens tellement proche de le raccourcir d'une ligne, grrrr ....

Essayez-le en ligne!

version encore plus jeune, 36 octets

"r2ss6&56F:M}R` &:P&Fo|ao{|;what????

Le code de celui-ci est plus petit, mais il revient toujours au même niveau malheureusement, le commentaire occupe le reste de l'espace.

Essayez-le en ligne!

version légèrement plus récente, 36 octets

"r2ss156F:M}F` o|:PP}Fo|ao{{|;Wowza!

Wowza! Hé, je viens de l'utiliser pour remplir de l'espace, mais le programme fonctionne, pour jouer au golf, j'ai utilisé quelques valeurs pré-poussées plutôt que d'utiliser des variables!

Essayez-le en ligne!

Version plus ancienne, 42 octets

"r2ss0V_~6:&F&:M&F` o|_PPV_Fo|ao|;empty...

Cela a une nouvelle ligne et a plus de caractères que je ne le voudrais ...

Je vais jouer au golf sévèrement ...

Essayez-le en ligne!

Nettoyer , 256 octets

module QQ;import StdEnv,Text;q=dec'#';$n#k=(s<+q<+s<+q)%(n^2,n^2+n*2)=lpad k(16+n)(dec q);Start=join{toChar 10}(map$[0..15]);s="module QQ;import StdEnv,Text;q=dec'#';$n#k=(s<+q<+s<+q)%(n^2,n^2+n*2)=lpad k(16+n)(dec q);Start=join{toChar 10}(map$[0..15]);s="

Essayez-le en ligne!

À peu près le quine standard, idéalement aussi un quine de modèle, avec la fonction de formatage ajoutée.

R , 169 144 octets

s='`!`=intToUtf8;cat(sprintf("%*s",11+(i=1:12),substring(paste0("s=",q<-!39,s,q,";eval(parse(t=s))"),(i-1)^2+1,i^2)),sep=!010)';eval(parse(t=s))

Essayez-le en ligne!

           s
          ='`
         !`=in
        tToUtf8
       ;cat(spri
      ntf("%*s",1
     1+(i=1:12),su
    bstring(paste0(
   "s=",q<-!39,s,q,"
  ;eval(parse(t=s))")
 ,(i-1)^2+1,i^2)),sep=
!010)';eval(parse(t=s))

A réussi à le raccourcir en passant à une chaîne qui est analysée plutôt qu'à une expression qui est partie. J'ai dû utiliser une redéfinition d'un opérateur unaire pour l'obtenir sous le 144.

C # (Visual C # Interactive Compiler) , 225 octets

var s="var s={0}{1}{0};for(int i=0;;)WriteLine(string.Format(s,(char)34,s).Substring(i*i++,2*i-1).PadLeft(i+14,(char)2));//";for(int i=0;;)WriteLine(string.Format(s,(char)34,s).Substring(i*i++,2*i-1).PadLeft(i+14,(char)2));//

Utilise un STX comme rembourrage. Je ne savais pas que Kevin Cruijssen avait déjà soumis une copie exacte en java avant de poster jusqu'à ce que j'aie fini, mais j'ai décidé de poster quand même.

Essayez-le en ligne!