A tarefa é um desafio quine bastante simples, com uma reviravolta, você deve exibir seu código-fonte na forma de uma pirâmide. A forma de uma pirâmide é definida abaixo:

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

A principal limitação desse desafio é que seu quine deve conter exatamente exatamente bytes para não obstruir o padrão da pirâmide. Por exemplo, os seguintes tamanhos de programa funcionariam:

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

Portanto, se seu programa foi:

QWERTY

Não seria válido, porque organizaria como:

  Q
 WER
TY

No entanto, se o seu programa fosse QWERTYUIO, tudo bem:

  Q
 WER
TYUIO

Regras

• As brechas padrão são obviamente proibidas, não é possível ler sua própria fonte.
• A pirâmide deve estar centralizada, caracteres finais são permitidos, mas não são necessários.
  • Além disso, qualquer personagem pode ser usado para centralizar a pirâmide, não precisa ser (char)32.
• Sua solução deve poder ser transformada em pirâmide.
  • Ele deve manter a ordem original do seu código-fonte.
  • Seu código-fonte NÃO pode conter o caractere usado para formatar a pirâmide.
  • Por exemplo, se seu código-fonte contiver um espaço, você precisará de outro caractere para o formato.
• Você pode usar comentários em seu quine para "preencher" o tamanho correto.
  • Obviamente, estes devem ser produzidos como parte da solução.
• Se o programa contiver novas linhas / guias, elas não fazem parte do quine e devem ser omitidas na saída.
• A forma é contada em caracteres, não em bytes; se a forma estiver malformada, você não está fazendo certo.

A pontuação mais baixa possível aqui deve ser 4.

05AB1E , 36 bytes

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

Experimente online!

Se trailing characters are allowedtambém significa no final da saída, 0"D34çýā·<£.c"D34çýā·<£.cé uma camada mais curta com 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 graças a @JoKing .

Saídas com espaços à esquerda para fazer o triângulo. (Observe que os espaços em branco entre var se int isão tabulações, não espaços.)

Experimente online.

Explicação:

quine -part:

• var s contém o código-fonte não formatado String
• %s é usado para colocar essa String em si mesma com s.format(...)
• %c, %1$cE 34são usados para formatar as aspas duplas ( ")
• %% é usado para formatar o %
• s.format(s,34,s) coloca tudo junto

Parte do desafio:

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

O que para com um java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226erro no String#substring(int,int)método, a iteração após a impressão do resultado (o que é bom de acordo com a 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)

Experimente online!

Uma avaliação avalia que usa espaços como o caractere de preenchimento.

Perl 6 , 67 bytes

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

Experimente online!

Usei alguns caracteres unicode para extrair essa camada extra. Saídas usando espaços:

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

Explicação:

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

Python 2 , 169 bytes

Usa 0para formatar a 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))

Experimente online!

Python 2 , 147 bytes

Isso usa a regra Se o programa contém novas linhas / guias, elas não fazem parte do quine e devem ser omitidas na saída.

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

Experimente online!

Gol> <> , 36 bytes

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

Experimente online!

uma versão ainda mais nova, 36 bytes

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

Eu me sinto tão perto de conseguir uma linha mais curta, grrrr ....

Experimente online!

versão ainda mais nova, 36 bytes

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

O código dessa pessoa é menor, mas ainda sai da mesma quantidade, infelizmente, o comentário ocupa o restante do espaço.

Experimente online!

versão um pouco mais nova, 36 bytes

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

Wowza! Hei, eu apenas usei isso para preencher um pouco de espaço, mas o programa funciona, para jogar golfe, usei alguns valores pré-pressionados em vez de usar variáveis!

Experimente online!

Versão antiga, 42 bytes

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

Isso tem uma nova linha à direita e tem mais caracteres do que eu gostaria ...

Eu vou jogar isso severamente ...

Experimente online!

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

Experimente online!

Praticamente o quine padrão, convenientemente também um template quine, com a função de formatação adicionada.

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

Experimente online!

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

Conseguiu encurtá-lo movendo-se para uma sequência que é analisada em vez de uma expressão que se foi. Teve que usar uma redefinição de um operador unário para colocá-lo sob os 144.

C # (compilador interativo do 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));//

Usa um STXcaractere como preenchimento. Não sabia que Kevin Cruijssen já havia enviado uma cópia exata em java antes de postar até que eu terminasse, mas decidi postar de qualquer maneira.

Experimente online!