Die Aufgabe ist eine ziemlich einfache Herausforderung mit einem Twist. Sie müssen Ihren Quellcode in Form einer Pyramide ausgeben. Die Form einer Pyramide ist unten definiert:

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

Die Hauptbeschränkung dieser Herausforderung besteht darin, dass Ihr Quine genau genug Bytes enthalten muss, um das Muster der Pyramide nicht zu behindern. Zum Beispiel würden die folgenden Programmlängen funktionieren:

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

Also, wenn Ihr Programm war:

QWERTY

Es wäre nicht gültig, weil es wie folgt arrangieren würde:

  Q
 WER
TY

Wenn Ihr Programm jedoch QWERTYUIO wäre, wäre es in Ordnung:

  Q
 WER
TYUIO

Regeln

• Standardlücken sind offensichtlich nicht zulässig, Sie dürfen Ihre eigene Quelle nicht lesen.
• Die Pyramide muss zentriert sein, nachfolgende Zeichen sind zulässig, aber nicht erforderlich.
  • Außerdem kann jedes Zeichen verwendet werden, um die Pyramide zu zentrieren, muss es aber nicht sein (char)32.
• Ihre Quine muss zu einer Pyramide geformt werden können.
  • Die ursprüngliche Bestellung Ihres Quellcodes muss beibehalten werden.
  • Ihr Quellcode darf NICHT das Zeichen enthalten, das zum Formatieren der Pyramide verwendet wird.
  • Wenn Ihr Quellcode ein Leerzeichen enthält, benötigen Sie ein weiteres Zeichen für das Format.
• Sie können Kommentare in Ihrem Quine verwenden, um die richtige Größe zu "füllen".
  • Offensichtlich müssen diese als Teil der Quine ausgegeben werden.
• Wenn das Programm Zeilenumbrüche enthält, sind diese nicht Teil des Quines und sollten in der Ausgabe weggelassen werden.
• Die Form wird in Zeichen und nicht in Bytes gezählt. Wenn die Form fehlerhaft ist, machen Sie es nicht richtig.

Die niedrigstmögliche Punktzahl sollte hier 4 sein.

05AB1E , 36 Bytes

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

Probieren Sie es online aus!

Wenn trailing characters are allowedauch am Ende der Ausgabe bedeutet, 0"D34çýā·<£.c"D34çýā·<£.cist eine Schicht mit 25 Bytes kürzer.

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 dank @JoKing .

Ausgaben mit führenden Leerzeichen, um das Dreieck zu bilden. (Beachten Sie, dass die Leerzeichen zwischen var sund int iTabulatoren und keine Leerzeichen sind.)

Probieren Sie es online aus.

Erläuterung:

Quine-Teil :

• var s enthält den unformatierten Quellcode String
• %s wird verwendet, um diesen String mit sich selbst in sich zu setzen s.format(...)
• %c, %1$cUnd 34werden verwendet , um die doppelten Anführungszeichen zu formatieren ( ")
• %% wird verwendet, um die zu formatieren %
• s.format(s,34,s) fasst alles zusammen

Herausforderungsteil:

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

Was mit einem java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226Fehler für die String#substring(int,int)Methode endet, die Iteration nach dem Drucken des Ergebnisses ( was laut Meta in Ordnung ist ).

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)

Probieren Sie es online aus!

Eine Bewertung, bei der Leerzeichen als Füllzeichen verwendet werden.

Perl 6 , 67 Bytes

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

Probieren Sie es online aus!

Ich habe ein paar Unicode-Zeichen verwendet, um diese zusätzliche Ebene herauszudrücken. Ausgaben mit Leerzeichen:

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

Erläuterung:

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

Python 2 , 169 Bytes

Dient 0zum Formatieren der 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))

Probieren Sie es online aus!

Python 2 , 147 Bytes

Dies verwendet die Regel. Wenn das Programm Zeilenumbrüche / Tabulatoren enthält, sind diese nicht Teil des Quines und sollten in der Ausgabe weggelassen werden.

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

Probieren Sie es online aus!

Gol> <> , 36 Bytes

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

Probieren Sie es online aus!

eine noch jüngere Version, 36 Bytes

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

Ich fühle mich so nah dran, es eine Zeile kürzer zu machen, grrrr ....

Probieren Sie es online aus!

noch jüngere Version, 36 Bytes

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

Der Code dieses einen ist kleiner, aber leider kommt er immer noch in der gleichen Menge heraus. Der Kommentar nimmt den Rest des Platzes ein.

Probieren Sie es online aus!

etwas jüngere Version, 36 Bytes

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

Wowza! Heh, ich habe das nur benutzt, um etwas Platz zu füllen, aber das Programm funktioniert, um Golf zu spielen, habe ich ein paar vorgefertigte Werte verwendet, anstatt Variablen zu verwenden!

Probieren Sie es online aus!

Ältere Version, 42 Bytes

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

Dies hat einen nachgestellten Zeilenumbruch und mehr Zeichen als ich möchte ...

Ich werde so heftig Golf spielen ...

Probieren Sie es online aus!

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

Probieren Sie es online aus!

So ziemlich das Standard-Quine, praktisch auch ein Template-Quine, mit der hinzugefügten Formatierungsfunktion.

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

Probieren Sie es online aus!

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

Es ist gelungen, es zu verkürzen, indem Sie zu einer Zeichenfolge wechseln, die analysiert wird, und nicht zu einem Ausdruck, der nicht mehr angezeigt wird. Musste eine Neudefinition eines unären Operators verwenden, um es unter die 144 zu bekommen.

C # (Visual C # Interactive Compiler) , 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));//

Verwendet ein STXZeichen als Polsterung. Ich wusste nicht, dass Kevin Cruijssen vor dem Posten bereits eine genaue Kopie in Java eingereicht hatte, bis ich fertig war, aber ich entschied mich trotzdem, dies zu posten.

Probieren Sie es online aus!