Sua tarefa é escrever um programa de tamanho uniforme , que imprima um quadrado de arte ASCII (descrito abaixo), que aumente o comprimento do lado em 1 unidade cada vez que o código-fonte original é colado no meio do código atual.

É muito difícil para mim definir essa tarefa muito bem, então vou dar um exemplo:

• Digamos que seu código inicial era CODEe que era impresso:

  0
  

• Em seguida, insira CODEno meio: seu código se torna COCODEDEe deve ser impresso:

  00
  00
  

• Reinsira CODEno meio: seu código se torna COCOCODEDEDE e deve ser impresso:

  000
  000
  000
  

• E assim por diante. Sua resposta deve teoricamente funcionar após várias iterações, mas entendo se, devido às limitações de desempenho do idioma, ela não pode ser executada razoavelmente acima de um determinado limite.

Algumas regras:

• Você pode usar qualquer ASCII imprimível (32-127) como o caractere a ser usado no seu quadrado. Sua escolha precisa ser constante (você deve usar o mesmo caractere para cada iteração).

• O quadrado de saída inicial deve ter o comprimento lateral 1 .

• Um quadrado ascii-art é definido como uma string com N linhas (separadas por N-1 feeds de linha / novas linhas) e cada linha contém N cópias do caractere escolhido.

• Não é permitido que sua saída contenha espaços em branco externos, exceto uma nova linha à direita.

• Você pode usar os padrões para entrada e saída (programas ou funções são permitidos, mas trechos não são).

• O meio do seu código é definido como o ponto em que o código-fonte pode ser dividido em duas partes, para que as duas sejam iguais.

• Suas respostas serão pontuadas pela duração do seu programa original , em bytes. A menor contagem de bytes vence. Caso haja empate, a resposta enviada anteriormente vence.

• Você pode usar este programa para aplicar as inserções sem precisar fazer isso manualmente.

Pitão , 2 bytes

5

Experimente online! Também Experimente dobrou , triplicou !

Como isso funciona?

\né o comando que imprime seu argumento com uma nova linha à direita, enquanto o retorna simultaneamente. Portanto, toda vez que você faz uma inserção, transforma o literal inteiro 5 em um número contendo N cópias de 5 concatenadas, e as novas linhas principais basicamente garantem que seja impresso o número apropriado de vezes, mantendo-o quadrado.

JavaScript (ES6), 42 32 30 bytes

s=[this.s]+0;  console.log(s);

Segunda iteração:

s=[this.s]+0;  s=[this.s]+0;  console.log(s);console.log(s);

Isso funciona anexando a 0a scada vez que a primeira metade do código é executada e imprimindo- sse a cada vez que a segunda metade é executada. Aproveita quatro peculiaridades do JavaScript:

1. O ambiente atual pode ser referido com this. Isso nos permite fazer this.sno lugar de s.
2. Ao acessar uma propriedade que não foi definida em um objeto, em vez de gerar um erro, o JavaScript retorna undefined.
3. Uma matriz mais um número retorna uma sequência. [1,2,3] + 4 === "1,2,34"
4. Ao restringir uma matriz, ela undefinedé convertida na cadeia vazia, o que significa isso [undefined] + 0 === "0".

Juntos, isso significa que podemos expressar a primeira metade (gerando uma sequência de zeros) em apenas 13 bytes. Se usar em alertvez de console.logfor permitido, podemos salvar mais 4 bytes encurtando a segunda metade.

05AB1E , 2 bytes

5=

Experimente online!

Porto da minha resposta Pyth .

Python 2 , 42 38 28 bytes

id='%s@'%id  ;print id[22:];

Experimente online! . Você também pode tentar a segunda e a terceira iterações

Python 2 , 22 bytes

i=0;i+=1; i
print'*'*i

Experimente online!

Dobrado:

i=0;i+=1; ii=0;i+=1; i
print'*'*i
print'*'*i

Observe que a segunda metade começa com um caractere de nova linha.

C (GCC) , 170 168 96 80 72 70 bytes

Versão muito mais curta. Ainda desejo encontrar uma solução sem o pré-processador.

i;main(n){for(;i++<n;)printf
#if 0

#endif
(" %*c",n=__LINE__/4, 10);}

Experimente online!

Versão antiga de 168 bytes:

#ifndef A
#define A p(c){putchar(c);}j,n;main(i){for(
#else
#define A n++,
#endif
A



#ifndef B
#define B i=++n;i--;p(10))for(j=n;j--;)p(64);}
#else
#define B
#endif
B

Experimente online!

Python 2 , 30 bytes

False+=1      ;print'*'*False;

Experimente online! , 2 e 3 iteração

Isso faz uso do fato de que os bools no Python são basicamente ints e nomes Falsee Trueforam reatribuíveis no Python 2.

Python 1 , 32 bytes

exit=exit+'*'  ;print exit[30:];

Experimente online! , 2º e 3ª iteração

No Python 1, as strings internas exite quitexistiam para informar ao usuário do shell interativo como sair dele. O valor padrão é "Use Ctrl-D (i.e. EOF) to exit.".

Carvão , 6 bytes

⊞υωＬυ⸿

Experimente online! Explicação:

  ω     Predefined empty string (any variable would do here)
 υ      Predefined initially empty list
⊞       Push

υ termina com um comprimento do número de repetições.

    υ   List
   Ｌ    Length
        Implicitly print as a row of `-`s
     ⸿  Move to start of next line

Haskell , 68 bytes

let s@(z:n)="0\n"in case lines<$>[]of(h:t):_->(h:h:t)>>(z:h++n);_->s

Experimente online uma vez , duas vezes ou três vezes .

Por causa da preguiça de Haskell, uma expressão como a acima conta como uma função que não aceita argumentos, conforme esta pergunta do Meta .

brainfuck , 44 34 bytes

^{riscado 44 ainda é regular 44;}

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

Experimente online!

Tente dobrar , triplicar . Olha, sem preenchimento!

Imprime quadrados de U. Ele se divide bem no meio dos 10 +s.

Ruby, 18 bytes

$/=?x+$/;  puts$/;

Experimente online! Dobrado! Triplicado!

Flacidez Cerebral , 74 bytes

(((((()()()){}){}){}){})((()()()()()<>){})<>([]){({}[()]<(({})<>)<>>)}{}<>

Experimente online!

Tente dobrar e triplicar .

Explicação

(((((()()()){}){}){}){}) # push 48 ("0") onto first stack
((()()()()()<>){})       # push 10 (\n) onto second stack
<>([]){({}[()]<          # a number of times equal to the height of the first stack:
  (({})<>)<>             #   copy the top of the first stack to the second stack
>)}{}<>                  # cleanup and return to second stack

O ponto de interrupção está no meio da <>seção "push 10". Quebrar isso deixará um 5 na terceira pilha até chegarmos à segunda metade correspondente, altura em que pressionar 10 continuará exatamente de onde parou.

Embora seja possível enviar por push um valor ASCII (espaço) imprimível em 22 bytes, isso faria com que a central <>fosse executada após o envio 5. Ao adicionar mais dois bytes, eu pude mover o <>para que todo o progresso em direção ao push 10estivesse na terceira pilha. Como um bônus, isso também tornou o quadrado resultante mais esteticamente agradável.

tinylisp , 112 bytes

(load library) (d N((q((x)(i x(inc x)1)))(v(h(t(t(h(t(q())))))))))(join(repeat-val(string(repeat-val 42 N))N)nl)

Experimente online!Também dobrou e cinco vezes .

A abordagem "construa uma string na primeira metade, imprima na segunda metade" que muitas linguagens estão adotando não funcionará no tinylisp, pois não há variáveis ​​mutáveis. Em vez disso, fazemos um aninhamento de código sério.

Quando uma segunda cópia do código é inserida, ela é colocada dentro de (q()), o que envolve uma lista. Em seguida, (h(t(t(h(t(...))))))perfura essa lista para a parte após(d N . (v(...))avalia; passamos para a função sem nome (q((x)(i x(inc x)1))), que incrementa o valor resultante se for um número e retorna 1 se for a lista vazia. O resultado final na versão aninhada mais externa do código é atribuído N. Em essência, configuramos um tipo estranho de recursão que conta o número de níveis de aninhamento.

A segunda metade do código cria uma sequência de Nasteriscos, uma lista Ndessas seqüências e, em seguida, junta-se à lista em novas linhas. O resultado é exibido com uma nova linha à direita.

R , 44 bytes

F=F+1;T=TRUE*TRUE+12;
write(strrep(1,F),"");

Experimente online!

Imprime com uma nova linha à direita. oT=TRUE*TRUE+12 é apenas para preencher o comprimento.

Tente dobrar e tente triplicar .

Julia 0.6 , 29 bytes

Todas as minhas idéias foram mais longas do que adaptar a solução python inteligente do xnor.

i=0;i+=1;    i
println("0"^i)

Torna-se

i=0;i+=1;    ii=0;i+=1;    i
println("0"^i)
println("0"^i)

Experimente online!

SNOBOL4 (CSNOBOL4) , 130 68 bytes

Agora sem comentários! Veja o histórico de edições para obter uma explicação do antigo algoritmo.

	X =X + 1
	A =ARRAY(X,DUPL(1,X));
I	I =I + 1
	OUTPUT =A<I>	:S(I)
END

Experimente online!

Tente dobrar e triplicar

Explicação:

	X =X + 1		;* increment X
	A =ARRAY(X,DUPL(1,X));	;* create an x-length array with 1 repeated x times for each element
I	I =I + 1		;* for i < x
	OUTPUT =A<I>	:S(I)	;* output a[i]
END

Como um ENDrótulo é necessário e qualquer coisa após o primeiro ENDrótulo ser ignorado, temos duas vantagens para esse desafio:

• operações na primeira metade do programa são repetidas Xvezes para as Xrepetições
• (para o intérprete) existirá apenas uma cópia da segunda metade, incluindo rótulos .

Isso sugere que usamos a repetição para o primeiro semestre e, em seguida, podemos usar uma abordagem de rotulagem mais "convencional" para repetir a saída X tempos de .

A primeira metade é

	X =X + 1
	A =ARRAY(X,DUPL(1,X));

que, quando repetido, incrementa Xo número apropriado de vezes e cria um ARRAY Acom índices de e 1para Xonde cada elemento de Aé a sequência de vezes 1repetida X.

Então, não importa quantas vezes o programa seja repetido, o intérprete vê apenas:

I	I =I + 1
	OUTPUT =A<I>	:S(I)
END

que é um programa SNOBOL típico que imprime os elementos de Aum de cada vez até que o índice saia dos limites e finaliza o programa.

;é um terminador de linha opcional geralmente reservado para uma linha EVALou CODEinstruções que elevam a contagem de bytes para 68 e marcam a metade do caminho, permitindo que o código seja anexado a ela.

shortC , 56 44 bytes

^{-12 bytes: espere duh, estou usando shortC, por que não usar algumas coisas C reduzidas}

s[];A
strcat(s,"@");//
Js);/*filling space*/

Eu teria usado o padrão C, mas isso requer um }no final que mexe com a replicação. shortC o insere implicitamente no EOF.

• Experimente online! (1x1)
• Experimente online! (2x2)
• Experimente online! (3x3)
• ...
• Experimente online! (15x15)

Perl 5 , 25 bytes

Código de 24 bytes + 1 para -p.

Lembre-se de que talvez você não queira permitir sinalizadores de linha de comando, informe-me se isso não for válido.

$@=0 x++$n;;$_="$@
"x$n;

Experimente online!

Zsh , 10 bytes

s+=0
<<<$s

Experimente um conjunto completo de testes online!

... Sim, isso é um pouco melhor. Acrescente à seqüência N vezes e imprima N vezes. Acontece que <<<foo<<<foofunciona muito bem.

Zsh , 64 bytes

Personagem usado: (espaço).

f(){printf '%*s\n' $1}
:<<'E'

E
repeat $[i=LINENO/3];f $i
exit

Experimente um conjunto completo de testes online!

O ponto médio fica entre o segundo Ee a nova linha a seguir. Um heredoc terminará quando houver um Eem uma linha por si só, o que acontece exatamente no meio do código.