Il compito è una sfida piuttosto semplice con una svolta, è necessario generare il codice sorgente a forma di piramide. La forma di una piramide è definita di seguito:

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

Il limite principale di questa sfida è che il tuo quine deve contenere esattamente abbastanza byte da non ostruire il modello della piramide. Ad esempio, le seguenti lunghezze del programma funzionerebbero:

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

Quindi, se il tuo programma fosse:

QWERTY

Non sarebbe valido, perché organizzerebbe come:

  Q
 WER
TY

Tuttavia, se il tuo programma fosse QWERTYUIO, andrebbe bene:

  Q
 WER
TYUIO

Regole

• Le scappatoie standard sono ovviamente vietate, nessuna lettura della propria fonte.
• La piramide deve essere centrata, i caratteri finali sono consentiti, ma non richiesti.
  • Inoltre, qualsiasi personaggio può essere usato per centrare la piramide, non deve esserlo (char)32.
• Il tuo quine deve poter essere modellato in una piramide.
  • Deve conservare l'ordine originale del codice sorgente.
  • Il codice sorgente NON può contenere il carattere utilizzato per formattare la piramide.
  • Ad esempio, se il codice sorgente contiene uno spazio, è necessario un altro carattere per il formato.
• Puoi usare i commenti nel tuo quine per "riempire" la dimensione corretta.
  • Ovviamente, questi devono essere emessi come parte del quine.
• Se il programma contiene newline / tab, non fanno parte del quine e dovrebbero essere omessi nell'output.
• La forma viene contata in caratteri, non in byte; se la forma è deformata, non la stai facendo bene.

Il punteggio più basso possibile qui dovrebbe essere 4.

05AB1E , 36 byte

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

Provalo online!

Se trailing characters are allowedsignifica anche alla fine dell'output, 0"D34çýā·<£.c"D34çýā·<£.cè uno strato più corto di 25 byte.

Java 11, 324 256 227 byte

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 byte grazie a @JoKing .

Output con spazi iniziali per creare il triangolo. (Si noti che gli spazi bianchi tra var se int isono schede, non spazi.)

Provalo online.

Spiegazione:

quine- parte:

• var s contiene il codice sorgente non formattato String
• %s è usato per mettere questa stringa in sé con s.format(...)
• %c, %1$cE 34vengono utilizzati per formattare le virgolette ( ")
• %% è usato per formattare il file %
• s.format(s,34,s) mette tutto insieme

Parte sfida:

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

Che si interrompe con un java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226errore per il String#substring(int,int)metodo, l'iterazione dopo aver stampato il risultato ( che va bene secondo il meta ).

Python 2 , 81 byte

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

Provalo online!

Un qual eval che utilizza gli spazi come carattere di riempimento.

Perl 6 , 67 byte

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

Provalo online!

Ho usato un paio di personaggi unicode per eliminare quel livello in più. Output usando gli spazi:

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

Spiegazione:

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

Python 2 , 169 byte

Utilizza 0per la formattazione della piramide.

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

Provalo online!

Python 2 , 147 byte

Questo utilizza la regola Se il programma contiene newline / tab, non fanno parte del quine e dovrebbero essere omessi nell'output.

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

Provalo online!

Gol> <> , 36 byte

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

Provalo online!

una versione ancora più giovane, 36 byte

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

Mi sento così vicino a renderlo più corto di una riga, grrrr ....

Provalo online!

versione ancora più giovane, 36 byte

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

Il codice di questo è più piccolo, ma esce purtroppo nella stessa quantità, il commento occupa il resto dello spazio.

Provalo online!

versione leggermente più giovane, 36 byte

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

Wowza! Heh, l'ho appena usato per riempire un po 'di spazio, ma il programma funziona, per giocare a golf, ho usato alcuni valori precomposti piuttosto che usare le variabili!

Provalo online!

Versione precedente, 42 byte

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

Questo ha una nuova riga finale e ha più caratteri di quanti vorrei ...

Ho intenzione di giocare a golf così severamente ...

Provalo online!

Pulito , 256 byte

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

Provalo online!

Praticamente lo standard quine, convenientemente anche un template quine, con la funzione di formattazione aggiunta.

R , 169 144 byte

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

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

Riuscito ad accorciarlo spostandosi su una stringa analizzata anziché su un'espressione che è partita. Ho dovuto usare una ridefinizione di un operatore unario per farlo rientrare nei 144.

C # (compilatore interattivo Visual C #) , 225 byte

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

Utilizza a STX carattere come imbottitura. Non mi ero reso conto che Kevin Cruijssen avesse già inviato una copia esatta in java prima di postare fino a quando non avessi finito, ma ho deciso di pubblicarlo comunque.

Provalo online!