Desafio

Escreva o trecho mais curto possível de código, de modo que, quando N cópias forem concatenadas, o número de caracteres de saída seja N ² . N será um número inteiro positivo.

Por exemplo, se o snippet fosse soln();, a execução soln();imprimiria exatamente 1 caractere e a execução soln();soln();imprimiria exatamente 4 caracteres, e a execução soln();soln();soln();imprimiria exatamente 9 caracteres, etc.

Qualquer caractere pode estar na saída enquanto o número total de caracteres estiver correto. Para evitar confusão entre sistemas operacionais, as \r\nnovas linhas são contadas como um caractere.

Os programas podem não ler sua própria fonte ou seu tamanho de arquivo ou usar outras brechas. Tratar este como um estrito Quine desafio.

A saída pode ir para stdout ou um arquivo ou uma alternativa semelhante. Não há entrada.

Os comentários no código estão corretos, assim como o meio da execução.

Qualquer caractere pode estar no programa. O menor envio em bytes vence.

TECO, 4 bytes

V1\V

Vimprime o conteúdo da linha atual no buffer de texto. 1\insere a representação de sequência do número 1 na posição atual.

Portanto, na n- ésima iteração do programa, a primeira Vproduzirá N-1 cópias do caractere 1, depois adicionará outra 1ao texto e depois produzirá n 1 s.

Brainfuck, 17 16 bytes

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

Você pode testá-lo aqui . Apenas use o fato disso .n2+2n+1=(n+1)2

Brainfuck, 11

Eu vi a primeira resposta de Brainfuck e pensei que era muito longo :)

[.<]>[.>]+.

A saída pode ser mais fácil de ver se você substitui o plus por muito mais vantagens.

Na enésima iteração, cada loop gera N - 1 cópias do caractere com valor ASCII 1 e, em seguida, mais uma com +..

Python 2, 22

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

Imprime a sequência vazia, depois dois x, depois xquatro e assim por diante. Com a nova linha após cada sequência, isso sai para n*ncaracteres.

Uma cópia: "\n"(1 caractere)
Duas cópias: "\nxx\n"(4 caracteres)
Três cópias: "\nxx\nxxxx\n"(9 caracteres)

Para impedir que a variável inicial aseja reinicializada a cada execução, encerro o código com a ;a, que é benigno por si só, mas combinado com o próximo loop para criar o bode expiatório aaa ser atribuído. Esse truque não é meu; Eu vi isso em uma resposta anterior. Eu apreciaria se alguém pudesse me apontar para que eu pudesse dar crédito.

CJam, 6 bytes

LLS+:L

Usa o fato 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

Tenho certeza de que existe uma maneira muito curta e distorcida de resolver isso em ///, mas ainda não consegui encontrar nada além da maneira "direta":

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

Isso se baseia na abordagem da impressão de números ímpares consecutivos. O snippet consiste em um 1no início que é impresso e duas substituições que adicionam mais dois 1s à primeira parte de cada cópia consecutiva do snippet. Vamos passar por isso por N = 3. O seguinte deve ser lido em grupos de 3 ou mais linhas: 1. o código atual, 2. o (s) token (s) processado (s), 3. (e seguintes) um comentário sobre o que o token acima faz.

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 tão bem se movermos 1o final:

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

> <> , 14 bytes

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

Usa a idéia "soma de números inteiros ímpares consecutivos iniciando em 1". Ele começa com 1 e o multiplica por 100 a cada vez, aumentando progressivamente a duração da saída em incrementos de 2.

Por exemplo, anexar 5 cópias dá

1100100001000000100000000

Testei canalizando a saída para um arquivo e não vi uma nova linha à direita.

Demolir

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*~

Isso imprime N ² espaços onde Né o número de cópias do código.

Expansão do código :

],            "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";

Experimente online aqui

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 solução é equivalente a outra em Python. Certamente não vai ganhar, mas foi divertido :)

Perl, 14 bytes

print;s//__/;

Isso precisa ser executado com a -lopção de comando do Perl , que faz printacrescentar novas linhas.

Ele imprime a variável padrão e $_, em seguida, acrescenta dois sublinhados por substituição.

Exemplo:

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

__
____
______

Brainfuck, 10 caracteres

Ambas as soluções anteriores Brainfuck foram waaay muito longo (16 e 11 caracteres) então aqui está um mais curto:

+[.->+<]>+

No n-ésimo bloco, imprime 2*n-1caracteres (com pontos de código de 2*n-1até 1)

Prelúdio , 18 12 bytes

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

Isso imprime N ² guias. Ele assume um intérprete compatível com o padrão que imprime caracteres em vez de números; portanto, se você usar o intérprete Python, precisará definir NUMERIC_OUTPUTcomo False.

A idéia é simplesmente usar o topo da pilha (que é inicialmente 0) como 2(N-1)e imprimir as 2N-1guias, depois incrementar a parte superior da pilha em 2. Portanto, cada repetição imprime o próximo número ímpar de guias.

Java - 59/44 (dependendo dos requisitos)

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

Aparentemente, podemos assumir que o código é executado em uma classe.

Se puder ir dentro de um 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

Isso usa duas macros mágicas. __COUNTER__é uma macro que se expande para 0a primeira vez em que é usada, 1a segunda etc. É uma extensão do compilador, mas está disponível no mínimo pelo gcc, clang e pelo Visual Studio. __FILE__é o nome do arquivo de origem. Incluir um arquivo no C / C ++ é literalmente o mesmo que colá-lo diretamente no seu código-fonte, por isso foi um pouco complicado de usar.

Ainda seria possível usar essa técnica sem __COUNTER__. Nesse caso, a proteção padrão contra o uso do código duas vezes poderia ser usada para a #ifinstrução e __LINE__poderia ser usada para contar o número de caracteres necessários.

Dyalog APL, 20 19 bytes

Uma solução baseada em matriz.

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

Experimente aqui . Retorna uma sequência de repetições de . Explicação por explosão 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

Há uma nova linha à direita para garantir que a instrução display (di) funcione. Primeiro, exiba o número atual em $ a novas linhas (e um adicional do padrão de exibição). Adicione 2 a $ a.

Usa a abordagem de números pares (ou seja, números ímpares se aproximam de menos 1) com uma nova linha extra toda 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 #

Observe o espaço à direita para garantir que a condição if seja verificada corretamente sempre.

Usa a abordagem de números ímpares. Não tenho certeza se há uma nova linha nas instruções selecionadas.

Não tenho certeza se existe uma maneira mais curta de criar uma tabela, se ela não existir.

PostScript, 35 caracteres

count dup 2 mul 1 add string print

Cada passe "vaza" uma coisa na pilha, então count aumenta 1 em cada vez. Então ele usa o truque da soma dos números ímpares.

A saída de bytes é toda \000porque esse é o valor inicial das strings.

Haskell, 72

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

Explicação

O operador apply $atua como se você colocasse parênteses ao redor do resto da linha (há exceções, mas funciona neste caso). aputStré uma função que usa uma string com o formato "abc ...", em que "abc" é a raiz quadrada do comprimento da string, incluindo abc. Ele analisará a string como um número inteiro e retornará uma string iniciando com abc + 1 e tendo esse comprimento ao quadrado. Por causa do $operador, isso será chamado recursivamente em "1" N vezes.

Pitão, 8 bytes

*d*2Z~Z1

Isso se baseia no fato de que N ² é igual à soma dos Nnúmeros ímpares. Agora Pyth auto imprime uma linha nova, então eu tenho que apenas imprimir Z * 2caracteres em cada código onde Zvai desde 0a N - 1.

Expansão do 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";

Experimente online aqui

Golflua, 23 bytes

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

produz uma combinação de &e \ncaracteres.

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 o snippet de código é executado, produz mais 2 caracteres de saída que na última vez, começando com 1 caractere. A printfunção acrescenta uma nova linha, então eu inicializo X para 0 em vez de 1.

ActionScript - 27/26 bytes

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

ou

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

Como funciona:

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

Simplesmente comenta a primeira linha. Nota: traceadiciona uma nova linha. Ou talvez todos os IDEs que eu faço façam isso automaticamente.

GML, 27

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