Unir N copias de un fragmento para producir N ^ 2 caracteres

30

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

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.

Pasatiempos de Calvin
fuente
¿El programa tiene que terminar?
Martin Ender
@ MartinBüttner Sí
las aficiones de Calvin el

Respuestas:

24

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.

Feersum
fuente
1
¿Puedes agregar un enlace a TECO?
Erik the Outgolfer
22

Brainfuck, 17 16 bytes

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

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

alephalpha
fuente
16
¡No puedo creer que esté viendo BF a un nivel competitivo de bytes!
agweber
21

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

Feersum
fuente
Necesita imprimir N ^ 2 caracteres, no N caracteres. No puedo leer el código BF, así que no sé si su código es incorrecto o si su descripción es incorrecta.
Brian J
@BrianJ Imprime N ^ 2 caracteres. Puede probarlo aquí: copy.sh/brainfuck Reemplace el signo más con un signo menos si no puede ver el resultado.
alephalpha
@alephalpha Vaya, ahora veo que leí mal el comentario. El código no hace (N - 1) + 1 como originalmente pensé.
Brian J
16

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.

xnor
fuente
En realidad, ¿se imprime la nueva línea final?
xnor
no, no creo que se imprima la nueva línea final. Pero simplemente eliminar el ,after print adebería funcionar. print aimprime una nueva línea después de cada impresión.
Justin
@Quincunx ¡Oh, por supuesto, gracias!
xnor
¿Estás hablando de esta publicación ?
Sp3000
10

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.";
Martin Ender
fuente
:L..1+Es la misma idea en GolfScript.
Peter Taylor
@PeterTaylor Estaba pensando ..n+en GolfScript, pero esa molesta línea nueva ... :(
Martin Ender
Ja, tienes razón. No es necesario :Lporque no se usa.
Peter Taylor
10

/// , 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
Martin Ender
fuente
7

> <> , 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
Sp3000
fuente
5

CJam, 10 9 bytes

],)_S*a*~

Esto imprime N 2 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í

Optimizador
fuente
5

Python 2, 20 bytes

g=0
print'g'*g;g+=2#
Feersum
fuente
5

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

cygnusv
fuente
¿No necesitas una clase para ejecutar nada?
No, ya que OP solicitó fragmentos de código. Podemos suponer que esto se ejecuta dentro de un main, por ejemplo.
cygnusv
Entonces tengo una solución de 59 o incluso 44 bytes.
Genial :) Prefiero una frase, ¡pero la tuya es más corta!
cygnusv
4

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//__/;'

__
____
______
grc
fuente
las banderas se cuentan como 1 byte más por bandera
Optimizer
¿Qué hay de say?
hmatt1
@chilemagic Lo intenté, pero no pude hacerlo funcionar en mis versiones de Perl.
grc
@grc es la versión 5.10 y superior y necesitas en su -Elugar.
hmatt1
@chilemagic hmm, eso no pareció funcionar para mí en 5.16.
grc
4

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)

randomra
fuente
2
Esto no funcionaría en un brainfuck estándar, solo si las células son de tamaño ilimitado. En realidad, tampoco tendría sentido. ¿Cómo se genera el código de caracteres 1 billón?
fiesta del
3

Preludio , 18 12 bytes

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

Esto imprime N 2 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.

Martin Ender
fuente
3

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

fuente
3

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.

Feersum
fuente
Esta solución no está escrita en C, sino más bien en un dialecto de C. Por favor corrija el nombre del idioma.
FUZxxl
2
@FUZxxl La mayoría de las respuestas de código de golf solo están diseñadas para funcionar en gcc, por lo que no estoy seguro de por qué esto sería un problema.
feersum
No lo es, pero realmente deberías declarar eso.
FUZxxl
Estoy confundido. ¿Por qué declarar un no problema? O_o
corsiKa
@corsiKa Solo es un problema si lo declaras. El C gcc habla no es el estándar C.
FUZxxl
2

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'.
Zgarb
fuente
2

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.

comentarios
fuente
2

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.

comentarios
fuente
2
Felicitaciones por una elección de idioma inusual.
Xynariz
2

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.

Ben Jackson
fuente
2

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.

Jmac
fuente
1

Pyth, 8 bytes

*d*2Z~Z1

Esto se basa en el hecho de que N 2 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í

Optimizador
fuente
1

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.

Buscador14491
fuente
0

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.


fuente
0

GML, 27

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