Reto

Escriba el fragmento de código más corto posible de modo que, cuando N copias de él se concatenan juntas, el número de caracteres de salida es N ² . N será un entero positivo.

Por ejemplo, si el fragmento era soln();, entonces ejecutar soln();imprimirá exactamente 1 carácter, y ejecutar soln();soln();imprimirá exactamente 4 caracteres, y ejecutar soln();soln();soln();imprimirá exactamente 9 caracteres, etc.

Cualquier carácter puede estar en la salida siempre que el número total de caracteres sea correcto. Para evitar la confusión entre sistemas operativos, las \r\nnuevas líneas se cuentan como un carácter.

Los programas no pueden leer su propia fuente o leer el tamaño de su archivo o usar otras lagunas. Trate esto como un estricto desafío quine

La salida puede ir a stdout o un archivo o una alternativa similar. No hay entrada

Los comentarios en el código están bien, ya que está saliendo a mitad de la ejecución.

Cualquier personaje puede estar en el programa. La presentación más corta en bytes gana.

TECO, 4 bytes

V1\V

Vimprime el contenido de la línea actual en el búfer de texto. 1\inserta la representación de cadena del número 1 en la posición actual.

Así que en el N º iteración del programa, la primera Ves la salida N - 1 copias del personaje 1, a continuación, añadir otra 1al texto, entonces la salida N 1 s.

Brainfuck, 17 16 bytes

[>+>-..+<<-]-.>+

Puedes probarlo aquí . Solo usa el hecho de que .n2+2n+1=(n+1)2

Brainfuck, 11

Vi la primera respuesta de Brainfuck y pensé que era demasiado tiempo :)

[.<]>[.>]+.

La salida puede ser más fácil de ver si reemplaza el plus con muchas más ventajas.

En la enésima iteración, cada bucle genera N - 1 copias del carácter con el valor ASCII 1, y luego una más con +..

Pitón 2, 22

a='';print a;a+='xx';a

Imprime la cadena vacía, luego dos x, luego x'cuatro y así sucesivamente. Con la nueva línea después de cada cadena, esto sale a los n*ncaracteres.

Una copia: "\n"(1 carácter)
Dos copias: "\nxx\n"(4 caracteres)
Tres copias: "\nxx\nxxxx\n"(9 caracteres)

Para evitar que la variable inicial ase reinicie en cada ejecución, finalizo el código con un;a , que es benigno por sí solo, pero combinado con el siguiente ciclo para crear el chivo expiatorio aaque se asignará en su lugar. Este truco no es mío; Lo vi en una respuesta anterior. Agradecería si alguien me pudiera señalar para que yo pudiera dar crédito.

CJam, 6 bytes

LLS+:L

Utiliza el hecho de que .n2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 bytes

Estoy seguro de que hay una forma realmente corta y retorcida de resolver esto en /// pero todavía no pude encontrar nada, más allá de la forma "directa":

1/1\//112\///2\//1\//

Esto se basa en el enfoque de imprimir números impares consecutivos. El fragmento consiste en un 1al principio que se imprime, y dos reemplazos que agregan dos 1s más a esa primera parte de cada copia consecutiva del fragmento. Veamos esto por N = 3. Lo siguiente debe leerse en grupos de 3 o más líneas: 1. el código actual, 2. los tokens procesados, 3. (y siguientes) un comentario sobre lo que hace el token anterior.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

Curiosamente, funciona igual de bien si movemos 1al final:

/1\//112\///2\//1\//1

> <> , 14 bytes

1:na*a*';'10p!

Utiliza la idea de "suma de enteros impares consecutivos a partir de 1". Comienza con 1 y lo multiplica por 100 cada vez, aumentando la longitud de la salida progresivamente en incrementos de 2.

Por ejemplo, agregar 5 copias da

1100100001000000100000000

Probé canalizando la salida a un archivo, y no vi una nueva línea final.

Descompostura

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 bytes

],)_S*a*~

Esto imprime N ² espacios donde Nes el número de copias del código.

Código de expansión :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

Pruébalo en línea aquí

Python 2, 20 bytes

g=0
print'g'*g;g+=2#

Java - 91 bytes

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

Esta solución es equivalente a esta otra en Python. Seguramente no ganará, pero fue divertido :)

Perl, 14 bytes

print;s//__/;

Esto debe ejecutarse con el -linterruptor de comando de Perl , lo que hace printque se agreguen nuevas líneas.

Imprime la variable predeterminada $_, luego antepone dos guiones bajos mediante sustitución.

Ejemplo:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 caracteres

Ambas soluciones anteriores de Brainfuck fueron muuuucho más largas (16 y 11 caracteres), así que aquí hay una más corta:

+[.->+<]>+

En el nbloque -th imprime 2*n-1caracteres (con puntos de código de 2*n-1a 1)

Preludio , 18 12 bytes

^1+(9!1-)#2+

Esto imprime N ² pestañas. Supone un intérprete compatible con el estándar que imprime caracteres en lugar de números, por lo que si se utiliza el intérprete de Python que tendrá que establecer NUMERIC_OUTPUTa False.

La idea es simplemente usar la parte superior de la pila (que inicialmente es 0) como 2(N-1), e imprimir 2N-1pestañas, luego incrementar la parte superior de la pila en 2. Por lo tanto, cada repetición imprime el siguiente número impar de pestañas.

Java: 59/44 (según los requisitos)

static String n="1";
static{System.out.print(n);n+="11";}//

Aparentemente se nos permite asumir que el código se ejecuta en una clase.

Si puede entrar dentro de un método principal:

String n="1";
System.out.print(n);n+="11";//

C, 87 bytes

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

Esto usa dos macros mágicas. __COUNTER__es una macro que se expande a 0la primera vez que se usa, 1la segunda, etc. Es una extensión del compilador, pero está disponible en gcc, clang y Visual Studio al menos. __FILE__es el nombre del archivo fuente. Incluir un archivo en C / C ++ es literalmente lo mismo que pegarlo directamente en su código fuente, por lo que fue un poco difícil de usar.

Todavía sería posible utilizar esta técnica sin __COUNTER__. En ese caso, la protección estándar contra el uso del código dos veces podría usarse para la #ifdeclaración, y __LINE__podría usarse para contar la cantidad de caracteres necesarios.

Dyalog APL, 20 19 bytes

Una solución basada en matriz.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Probar aquí . Devuelve una cadena de repeticiones de . Explicación por explosión para :N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

STATA 20

di _n($a)
gl a=$a+2

Hay una nueva línea final para asegurarse de que la instrucción display (di) funciona. Primero muestre el número actual en $ a líneas nuevas (y uno adicional desde el valor predeterminado de visualización). Luego suma 2 a $ a.

Utiliza el enfoque de números pares (es decir, el enfoque de números impares menos 1) con una nueva línea adicional cada vez.

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Tenga en cuenta el espacio final para asegurarse de que la condición if se verifica correctamente cada vez.

Utiliza el enfoque de números impares. No estoy seguro si hay una nueva línea en las declaraciones de selección.

No estoy seguro si hay una forma más corta de crear una tabla si no existe.

PostScript, 35 caracteres

count dup 2 mul 1 add string print

Cada pase "filtra" una cosa en la pila, por lo que countsube 1 cada vez. Entonces simplemente usa el truco de la suma de números impares.

La salida de bytes se \000debe a que ese es el valor inicial de las cadenas.

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

Explicación

El operador de aplicación $actúa como si colocara paréntesis alrededor del resto de la línea (hay excepciones a esto, pero funciona en este caso). aputStres una función que toma una cadena con el formato "abc ...", donde "abc" es la raíz cuadrada de la longitud de la cadena, incluido abc. Analizará la cadena como un entero y devolverá una cadena que comience con abc + 1 y que tenga esa longitud al cuadrado. Debido al $operador, esto se llamará recursivamente en "1" N veces.

Pyth, 8 bytes

*d*2Z~Z1

Esto se basa en el hecho de que N ² es igual a la suma de Nnúmeros impares. Ahora Pyth automática imprime una línea nueva, así que tengo que acaba de imprimir Z * 2caracteres en cada código en la que Zva de 0a N - 1.

Expansión de código :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

Pruébalo en línea aquí

Golflua, 23 bytes

X=2+(X|-2)w(S.t("&",X))

produce una combinación de &y\n caracteres.

Código Lua equivalente

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Cada vez que se ejecuta el fragmento de código, produce 2 caracteres más de salida que la última vez, comenzando con 1 carácter. La printfunción agrega una nueva línea, por lo que inicializo X a 0 en lugar de 1.

ActionScript: 27/26 bytes

var n=""
trace(n);n+="11"//

o

var n=1
trace(n);n+="11"//

Cómo funciona:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

Simplemente comenta la primera línea. Nota: traceagrega una nueva línea. O tal vez todos los IDE que utilizo lo hacen automáticamente.

GML, 27

a=''show_message(a)a+='xx'a