Para este desafío, debe crear un programa que tome un número entero xy genere su fuente xmuchas veces.

Reglas

• Esto es codegolf, el objetivo es jugar golf en su programa para tener la menor cantidad de bytes

• Si envía una función, la función debe tomar xcomo parámetro y devolver o imprimir la totalidad de su código xmuchas veces a STDOUT. El cuerpo de la función tampoco debe estar vacío.

• Si envía una lambda, no es necesario que la asigne a una variable

• Se aplican restricciones de escapatoria estándar .

• Los programas vacíos están prohibidos.

• Su programa solo tiene que funcionar cuando xes un entero entero mayor o igual a 0

• Su programa tampoco puede leer directamente ninguna parte de su código fuente

Python 2 , 50 bytes

Tenga en cuenta la coma final y la nueva línea.

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

Pruébalo en línea!

Japt , 14 bytes

"iQ ²pU"iQ ²pU

Pruébalo en línea!

Explicación

"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

{`{.*¶}{

¡El RProgN2 Loop quine funciona particularmente bien para esto!

{     } # 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.

Pruébalo en línea!

Mathematica, 40 33 bytes

¡Gracias a lanlock4 por guardar 7 bytes!

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

Función pura que toma un argumento entero no negativo. ToString[#0]es la forma estándar de Mathematica de acceder a la definición de la función pura actual; StringRepeat[..., #1]concatena (entrada) copias de esa cadena juntas. Por ejemplo,

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

rendimientos:

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

V , 11 bytes

ÀñAÀÑ~"qpx

Pruébalo en línea!

Esta es una modificación extremadamente trivial de la V quine extensible estándar . Simplemente lo usamos Àpara ejecutarlo arg1 veces.

dc , 31 bytes

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

Pruébalo en línea!

Explicación:

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

Esta solución funciona si x=0. Hay una nueva línea final.

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

Pruébalo en línea

Python 2, 60 bytes (inválido)

Esto supone eso x>=1, pero el OP aclaró que xpuede ser cero. Hay una nueva línea final.

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

Pruébalo en línea

Baja carga , 12 bytes

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

Pruébalo en línea!

Envío de funciones, porque Underload no tiene otra forma de tomar entrada. (El enlace TIO muestra el número 4 dado como entrada y agrega código para imprimir la salida resultante).

Esto es solo un constructor universal de quine (a(:^)*):^, más ~^("hacer una cantidad de copias igual al argumento").

Japt , 14 bytes

*E îQi"*E îQi"

Pruébalo en línea!

Jalea , 10 bytes

“;⁾vṾẋɠ”vṾ

Pruébalo en línea!

Cómo funciona

“;⁾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.

Marca GNU , 49 bytes

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

Make unirá las copias por un solo espacio, así que tengo que incluir el carácter de espacio adicional al final y eliminarlo con un espacio stripintermedio para cumplir fielmente el requisito.

Pyth, 17 bytes

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

Pruébalo en línea!

Extensión trivial a la jN*2]"jN*2]quine bastante conocida , pero probablemente se pueda jugar golf

Betaload , 203 bytes

Nuevas líneas agregadas para mayor claridad:

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

Me di la restricción de que debe leer desde STDIN en lugar de desde la parte superior de la pila como lo haría normalmente una respuesta de baja carga. También utilicé la entrada decimal correcta, que constituye la mayor parte del código.

Explicación:

Envuelvo el programa en un quine-wrapper: (a(:^)*y ):^. Esto significa que todo el código dentro del contenedor de quine tendrá el código fuente del programa en la parte inferior de la pila.

Para convertir dígitos en un número normal de la Iglesia, utilizo la técnica de reemplazar cada dígito con el código para multiplicar por 10 y agregar ese dígito:

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

Aquí hay mucha repetición, así que empaquételo en un subprograma que tomará un número de la Iglesia de la parte superior de la pila y úselo para construir la "cadena de dígitos":

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

Puse esto en un nuevo entorno para que se pueda acceder rápidamente:

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

Ahora puedo crear el código de reemplazo para R. Rusa los elementos superiores de la pila para formar una tabla de búsqueda para reemplazar una cadena de STDIN con código Betaload. Funciona así:

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

Sin embargo, podemos usar el subprograma que acabamos de hacer para generar los segmentos de código:

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

Cuando Rse ejecuta, transformará la entrada en una serie de subprogramas que construyen un número de Iglesia. Cuando se ejecuta este subprograma, crea ese número de Iglesia en el siguiente elemento de la pila (0, que se colocó anteriormente). Esto significa que, después R^, el valor superior en la pila será el número de la Iglesia. Luego, ^una vez más, aplicamos el número de la Iglesia al elemento final en la pila (el código fuente del programa) para obtener la respuesta.

Dato curioso: he tenido el MD para esta presentación durante varios meses. Lo guardé después de haber malinterpretado una pregunta (que parece que ya no puedo encontrar). Tuve que desenterrarlo de mi Papelera de reciclaje para publicarlo aquí.

05AB1E , 23 bytes

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

Pruébalo en línea!

Python 2 , 41 bytes

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

Pruébalo en línea!

¿Tiene una salida un poco hacky usar inputen lugar de print, ya que printtiene un bicho raro que implica la impresión de una nueva línea cuando no se supone que ... . Sale con un error EOF.

Explicación:

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

Pruébalo en línea!

Pyth, 13 bytes

*jN*2]"*jN*2]

Banco de pruebas

El estándar Pyth quine más dos *para la repetición.

Perl, 48 bytes

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

\47es el escape octal para una comilla simple ( '). Se interpreta entre comillas dobles ( "), pero no entre comillas simples.

Javascript ES6, 27 37 bytes

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

Editar

+10 bytes si f=también se debe mostrar

f=

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

f(2);

CJam , 20 12 bytes

8 bytes guardados gracias a Martin Ender

{"_~"+ri*}_~

Pruébalo en línea!

Explicacion

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

Pruébalo en línea!

No es nada golfístico, como suelen ser las b64 quines.

Go , 257254 bytes

Esto me duele

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

Pruébalo en línea!

Microscript II, 22 bytes:

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

Microscript II, 20 bytes (pero técnicamente inválido ya que accede al código fuente de un bloque de código):

{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 # (compilador interactivo de Visual C #) , 115 bytes

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

Pruébalo en línea!

05AB1E , 17 bytes

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

La modificación de la forma predeterminada quine 0"D34çý"D34çý añadiendo ×?.

Pruébalo en línea.

Explicación:

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