Für diese Herausforderung müssen Sie ein Programm erstellen, das eine Ganzzahl annimmt xund seine Quelle xmehrmals ausgibt .

Regeln

• Dies ist Codegolf. Das Ziel ist es, Ihr Programm so zu golfen, dass es die geringste Anzahl von Bytes enthält

• Wenn Sie eine Funktion übergeben, muss die Funktion xals Parameter dienen und den gesamten Code xmehrmals an STDOUT zurückgeben oder ausdrucken . Der Funktionskörper darf auch nicht leer sein

• Wenn Sie ein Lambda einreichen, ist es nicht erforderlich, dass Sie es einer Variablen zuweisen

• Es gelten die üblichen Lückenbeschränkungen.

• Leere Programme sind verboten

• Ihr Programm muss nur funktionieren, wenn xeine ganze Zahl größer oder gleich 0 ist

• Ihr Programm liest möglicherweise auch keinen Teil seines Quellcodes direkt

Python 2 , 50 Bytes

Beachten Sie das nachstehende Komma und die Zeilenumbrüche.

s='s=%r;print s%%s*input(),\n';print s%s*input(),

Probieren Sie es online!

Japt , 14 Bytes

"iQ ²pU"iQ ²pU

Probieren Sie es online!

Erläuterung

"iQ ²pU"iQ ²pU
"iQ ²pU"       # Take this string
        iQ     # Prepend a quote
           ²   # Double the string (= source code)
            pU # Duplicate input times

RProgN 2 , 8 Bytes

{`{.*¶}{

Das RProgN2 Loop Quine eignet sich besonders gut dafür!

{     } # A function literal
       {# Without a matching }, this loops back to the second instruction, which essentially runs the function. This is a bug, but it works to make the "Looping Quine".
 `{.    # Append the literal {, stringifying the function.
    *   # Multiply the stringified function by the input.
     ¶  # Terminate the program.

Probieren Sie es online!

Mathematica, 40 33 Bytes

Danke an lanlock4 für das Speichern von 7 Bytes!

StringRepeat[ToString[#0], #1] & 

Reine Funktion, die ein nichtnegatives ganzzahliges Argument verwendet. ToString[#0]ist die Standardmethode von Mathematica, um auf die Definition der aktuellen reinen Funktion zuzugreifen. StringRepeat[..., #1]Verkettet (Eingabe) Kopien dieser Zeichenfolge miteinander. Beispielsweise,

StringRepeat[ToString[#0], #1] & [2]

ergibt:

StringRepeat[ToString[#0], #1] & StringRepeat[ToString[#0], #1] & 

V , 11 Bytes

ÀñAÀÑ~"qpx

Probieren Sie es online!

Dies ist eine äußerst triviale Modifikation des erweiterbaren Standard-V-Quines . Wir verwenden es einfach À, um es arg1- mal auszuführen .

Gleichstrom , 31 Bytes

[[1-rd91Pn93P[dx]Pdx]s.rd0<.]dx

Probieren Sie es online!

Erläuterung:

[[1-rd91Pn93P[dx]Pdx]s.rd0<.]dx
[     91Pn93P[dx]P          ]dx  # Same old regular quine
 [1-rd            dx]s.rd0<.     # Loop until the counter is zero

Python 2, 70 Bytes

Diese Lösung funktioniert, wenn x=0. Es gibt eine einzelne nachgestellte Zeile.

s='s=%r;exec"print%%r;"%%(s%%s)*input()';exec"print%r;"%(s%s)*input()

Probieren Sie es online aus

Python 2, 60 Bytes (ungültig)

Dies setzt voraus, dass x>=1aber das OP klarstellt, xdass Null sein kann. Es gibt eine einzelne nachgestellte Zeile.

s='s=%r;print(s%%s*input())[:-1]\n';print(s%s*input())[:-1]

Probieren Sie es online aus

Unterlast , 12 Bytes

(a(:^)*~^):^

Probieren Sie es online!

Funktionsübergabe, da Unterlast keine andere Möglichkeit hat, Eingaben vorzunehmen. (Der TIO-Link zeigt die Nummer 4 als Eingabe an und fügt Code zum Drucken der resultierenden Ausgabe hinzu.)

Dies ist nur ein universeller Quine-Konstruktor (a(:^)*):^, plus ~^("mache eine Anzahl von Kopien gleich dem Argument").

Japt , 14 Bytes

*E îQi"*E îQi"

Probieren Sie es online!

Gelee , 10 Bytes

“;⁾vṾẋɠ”vṾ

Probieren Sie es online!

Wie es funktioniert

“;⁾vṾẋɠ”vṾ  Main link. No arguments.

“;⁾vṾẋɠ”    Set the argument and the return value to the string ';⁾vṾẋɠ'.
         Ṿ  Uneval; yield '“;⁾vṾẋɠ”'.
        v   Eval ';⁾vṾẋɠ' with argument '“;⁾vṾẋɠ”'.
  ⁾vṾ           Yield 'vṾ'.
 ;              Concatenate '“;⁾vṾẋɠ”' and 'vṾ', yielding the source code.
      ɠ         Read an integer from STDIN.
     ẋ          Repeat the source code that many times.

GNU Make , 49 Bytes

$(foreach ,$(shell seq $1),$(strip $(value $0))) 

Make fügt die Kopien durch ein einzelnes Leerzeichen zusammen, sodass ich das zusätzliche Leerzeichen am Ende einfügen und mit einem stripdazwischenliegenden entfernen muss, um die Anforderung genau zu befolgen.

Pyth, 17 Bytes

j*]jN*2]"j*]jN*2]

Probieren Sie es online!

Triviale Erweiterung der bekannten jN*2]"jN*2]Quine, die sich aber wahrscheinlich zum Golfen eignet

Betaload , 203 Bytes

Zeilenumbrüche zur Verdeutlichung hinzugefügt:

(a(:^)*(!()):#(}:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*{)>(0)(!()){:^}(1)(){:^}(2)(:*){:^}(
3)(::**){:^}(4)(:*:*){:^}(5)(::*:**){:^}(6)(:*::**){:^}(7)(::*::***){:^}(8)(:*:*:*){:^}(9)(
::**::**){:^}R^^S):^

Ich gab mir die Einschränkung, dass es von STDIN lesen muss, anstatt von der Spitze des Stapels, wie es eine Unterlast-Antwort normalerweise tun würde. Ich habe auch die richtige Dezimaleingabe verwendet, die den größten Teil des Codes ausmacht.

Erläuterung:

Ich packe das Programm in einen Quine-Wrapper: (a(:^)*und):^ . Dies bedeutet, dass der Quellcode des Programms für den gesamten Code im Quine-Wrapper ganz unten im Stapel angezeigt wird.

Um Ziffern in eine normale Kirchenzahl umzuwandeln, ersetze ich jede Ziffer durch den Code, multipliziere mit 10 und addiere diese Ziffer:

0 -> (::*:**:*)*
1 -> (::*:**:*)*(:)~*(*)*
2 -> (::*:**:*)*(::)~*(**)*
3 -> (::*:**:*)*(:::)~*(***)*

Es gibt hier eine Menge Wiederholungen, also packen wir es in ein Unterprogramm, das eine Church-Ziffer von der Oberseite des Stapels nimmt und sie verwendet, um die "Ziffernfolge" zu konstruieren:

:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*

Ich habe dies in eine neue Umgebung gestellt, damit schnell darauf zugegriffen werden kann:

#(}:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*{)>

Jetzt kann ich den Ersatzcode für erstellen R. RVerwendet die obersten Elemente des Stapels, um eine Nachschlagetabelle zu erstellen, in der eine Zeichenfolge aus STDIN durch Betaload-Code ersetzt wird. Das funktioniert so:

()
(0)(code for 0)
(1)(code for 1)
(2)(code for 2)
...
R

Wir können jedoch das soeben erstellte Unterprogramm verwenden, um die Codesegmente zu generieren:

(0)(!()){:^}
(1)(){:^}
(2)(:*){:^}
(3)(::**){:^}
...

Beim RAusführen wird die Eingabe in eine Reihe von Unterprogrammen umgewandelt, die eine Kirchenzahl bilden. Wenn dieses Unterprogramm ausgeführt wird, erstellt es diese Church-Ziffer für das nächste Element auf dem Stapel (0, das zuvor abgelegt wurde). Dies bedeutet, dass R^der oberste Wert auf dem Stapel die Church-Ziffer ist. Wir dann^ wenden die Church-Nummer noch einmal auf das letzte Element im Stapel (den Quellcode des Programms) an, um die Antwort zu erhalten.

Lustige Tatsache: Ich habe den MD für diese Einreichung seit mehreren Monaten. Ich hatte es behalten, nachdem ich eine Frage missverstanden hatte (die ich anscheinend nicht mehr finde). Ich musste es aus meinem Papierkorb ausgraben, um es hier zu posten.

05AB1E , 23 Bytes

"34çìDJ¹.D»"34çìDJ¹.D»

Probieren Sie es online!

Python 2 , 41 Bytes

_="input('_=%r;exec _'%_*input())";exec _

Probieren Sie es online!

Verwendet eine irgendwie hackige Ausgabe inputstatt print, da printes einen seltsamen Fehler gibt, bei dem eine neue Zeile gedruckt wird, wenn dies nicht der Fall sein soll ... . Wird mit einem EOF-Fehler beendet.

Erläuterung:

_="input('_=%r;exec _'%_*input())"; # Set _ to a string
exec _                              # Execute that string
input(                        )     # "print"
      '_=%r;exec _'%_               # The source code with _ formatted in
                     *input()       # Actual input many times

05AB1E , 27 25 Bytes

"34çs«DJ¹FD,"34çs«DJ¹FD,

Probieren Sie es online!

Pyth, 13 Bytes

*jN*2]"*jN*2]

Testsuite

Das Standard-Pyth-Quine plus zwei *für die Wiederholung.

Perl, 48 Bytes

print"$_\47"x(2*pop)for'print"$_\47"x(2*pop)for'

\47ist das oktale Escape für ein einfaches Anführungszeichen ( '). Es wird in doppelten Anführungszeichen ( "), aber nicht in einfachen Anführungszeichen interpretiert .

Javascript ES6, 27 37 Bytes

_=>alert(`${f.name}=${f}`.repeat(_))

Bearbeiten

+10 Bytes f=sollten ebenfalls angezeigt werden

f=

_=>alert(`${f.name}=${f}`.repeat(_))

f(2);

CJam , 20 12 Bytes

8 Bytes gespart dank Martin Ender

{"_~"+ri*}_~

Probieren Sie es online!

Exaplanation

{       e# Begin a block literal:
 "_~"+  e#  Add whatever's on the stack to the beginning of the array ['_', '~'].
 ri*    e#  Repeat the resulting array a number of times equal to the input.
}       e# Close the block. Push it on the stack.
_~      e# Copy it and run it.

PHP, 194 Bytes

<?php $a="PD9waHAgJGE9IiMiOyRpPSRhcmd2WzFdO3doaWxlKCRpLS0pZWNobyBzdHJfcmVwbGFjZShjaHIoMzUpLCRhLGJhc2U2NF9kZWNvZGUoJGEpKTs=";$i=$argv[1];while($i--)echo str_replace(chr(35),$a,base64_decode($a));

Probieren Sie es online!

Überhaupt nicht golfen, wie es B64-Quines sind.

Los , 257 254 Bytes

Das tut mir weh.

package main;import(."fmt";."strings";."strconv";."os");func main(){s:="package main;import(.\"fmt\";.\"strings\";.\"strconv\";.\"os\");func main(){s:=%q;n,_:=Atoi(Args[1]);Print(Repeat(Sprintf(s,s),n))}";n,_:=Atoi(Args[1]);Print(Repeat(Sprintf(s,s),n))}

Probieren Sie es online!

Mikroskript II, 22 Bytes:

"v{lqp}sN*h"v{lqp}sN*h

Microscript II, 20 Bytes (aber technisch ungültig, da es auf den Quellcode eines Codeblocks zugreift):

{s""+`"~sN*"s`+}~sN*

C 144 116 Bytes

i;main(a){for(i=getchar()-48;i--;)printf(a="i;main(a){for(i=getchar()-48;i--;)printf(a=%c%s%c,34,a,34);}",34,a,34);}

Python 3, 69 Bytes

s='s=%r\nx=int(input())\nprint(s%%s*x)\n'
x=int(input())
print(s%s*x)

C # (Visual C # Interactive Compiler) , 115 Byte

n=>{var s="n=>{{var s={0}{1}{0};for(int i=0;i++<n;)Write(s,(char)34,s);}}";for(int i=0;i++<n;)Write(s,(char)34,s);}

Probieren Sie es online!

05AB1E , 17 Bytes

0"D34çý×?"D34çý×?

Änderung der Standard- Quine 0"D34çý"D34çý durch Hinzufügen ×?.

Probieren Sie es online aus.

Erläuterung:

0                   # Push 0 to the stack
                    #  STACK: [0]
 "D34çý×?"          # Push the string 'D34çý×?' to the stack
                    #  STACK: [0, 'D34çý×?']
          D         # Duplicate this string
                    #  STACK: [0, 'D34çý×?', 'D34çý×?']
           34ç      # Push '"' to the stack
                    #  STACK: [0, 'D34çý×?', 'D34çý×?', '"']
              ý     # Join the stack by this '"' delimiter
                    #  STACK: ['0"D34çý×?"D34çý×?']
               ×    # Repeat the string the (implicit) input amount of times
                    #  input = 2 → STACK: ['0"D34çý×?"D34çý×?0"D34çý×?"D34çý×?']
                ?   # Output to STDOUT without trailing newline