La tarea es un desafío de quine bastante simple con un giro, debe generar su código fuente en forma de pirámide. La forma de una pirámide se define a continuación:

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

La principal limitación de este desafío es que su quine debe contener exactamente bytes suficientes para no obstruir el patrón de la pirámide. Por ejemplo, las siguientes duraciones de programa funcionarían:

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

Entonces, si su programa fue:

QWERTY

No sería válido, porque se organizaría como:

  Q
 WER
TY

Sin embargo, si su programa fuera QWERTYUIO, estaría bien:

  Q
 WER
TYUIO

Reglas

• Las lagunas estándar obviamente no están permitidas, no hay que leer su propia fuente.
• La pirámide debe estar centrada, los caracteres finales están permitidos, pero no son obligatorios.
  • Además, cualquier personaje puede usarse para centrar la pirámide, no tiene por qué serlo (char)32.
• Su quine debe poder tener forma de pirámide.
  • Debe conservar el orden original de su código fuente.
  • Su código fuente NO puede contener el carácter que se utiliza para formatear la pirámide.
  • Por ejemplo, si su código fuente contiene un espacio, necesitará otro carácter para el formato.
• Puede usar comentarios en su quine para "rellenar" al tamaño correcto.
  • Obviamente, estos deben salir como parte de la quine.
• Si el programa contiene nuevas líneas / pestañas, no son parte de la línea y deben omitirse en la salida.
• La forma se cuenta en caracteres, no en bytes; Si la forma está mal formada, no lo estás haciendo bien.

La puntuación más baja posible aquí debería ser 4.

05AB1E , 36 bytes

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

Pruébalo en línea!

Si trailing characters are allowedtambién significa al final de la salida, 0"D34çýā·<£.c"D34çýā·<£.ces una capa más corta de 25 bytes.

Java 11, 324 256 227 bytes

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 bytes gracias a @JoKing .

Salidas con espacios iniciales para hacer el triángulo. (Tenga en cuenta que el espacio en blanco entre var sy int ison pestañas, no espacios).

Pruébalo en línea.

Explicación:

quine -parte:

• var s contiene el código fuente sin formato String
• %s se usa para poner esta cadena en sí misma con s.format(...)
• %c, %1$cy 34se utilizan para formatear las comillas dobles ( ")
• %% se usa para formatear el %
• s.format(s,34,s) lo pone todo junto

Parte del desafío:

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

Lo que se detiene con un java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226error para el String#substring(int,int)método, la iteración después de que ha impreso el resultado ( que está bien según el meta ).

Python 2 , 81 bytes

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

Pruébalo en línea!

Una evaluación que utiliza espacios como el carácter de relleno.

Perl 6 , 67 bytes

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

Pruébalo en línea!

Usé un par de caracteres unicode para exprimir esa capa adicional. Salidas usando espacios:

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

Explicación:

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

Python 2 , 169 bytes

Usos 0para formatear la pirámide.

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

Pruébalo en línea!

Python 2 , 147 bytes

Esto usa la regla Si el programa contiene nuevas líneas / pestañas, no son parte de la quine y deberían omitirse en la salida.

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

Pruébalo en línea!

Gol> <> , 36 bytes

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

Pruébalo en línea!

una versión aún más joven, 36 bytes

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

Me siento tan cerca de hacerlo una línea más corta, grrrr ...

Pruébalo en línea!

versión aún más joven, 36 bytes

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

El código de este es más pequeño, pero lamentablemente sigue siendo la misma cantidad, el comentario ocupa el resto del espacio.

Pruébalo en línea!

versión ligeramente más joven, 36 bytes

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

Wowza! Heh, solo usé eso para llenar un poco de espacio, pero el programa funciona, para jugar golf, ¡usé algunos valores prepulsados ​​en lugar de usar variables!

Pruébalo en línea!

Versión anterior, 42 bytes.

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

Esto tiene una nueva línea final, y tiene más caracteres de los que me gustaría ...

Voy a jugar al golf severamente ...

Pruébalo en línea!

Limpio , 256 bytes

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

Pruébalo en línea!

Prácticamente el quine estándar, convenientemente también un quine de plantilla, con la función de formateo agregada.

R , 169 144 bytes

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

Pruébalo en línea!

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

Se las arregló para acortarlo moviéndose a una cadena que se analiza en lugar de a una expresión que se separó. Sin embargo, tuve que usar una redefinición de un operador unario para obtenerla por debajo del 144.

C # (compilador interactivo de Visual C #) , 225 bytes

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));//

Utiliza un STXchar como relleno. No me di cuenta de que Kevin Cruijssen ya había enviado una copia exacta en Java antes de publicar hasta que terminé, pero decidí publicar esto de todos modos.

Pruébalo en línea!