Houve alguns desafios envolvendo a duplicação do código fonte: aqui e aqui . A tarefa que temos aqui é um pouco mais difícil, mas deve ser executável em quase todos os idiomas.

Neste desafio, você receberá um número inteiro positivo arbitrário. Seu programa deve gerar esse número inteiro duplicado . Quando seu código-fonte é duplicado, ele recebe um número inteiro positivo e o produz ao quadrado .

Como seu código fonte é duplicado? Bem, você pode fazer do seu jeito . Ou seja, você pode dividir seu código-fonte se em cadeias de bytes ou caracteres (ou fichas em langs tokenized) de qualquer igual comprimento desejado , e repetir cada pedaço duas vezes consecutivas.

Para um programa inicial de ABCDEFGHIJKL, (comprimento 12), aqui estão todos os programas duplicados possíveis:

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

Observe que isso significa que programas com comprimentos primos só podem ser duplicados de duas maneiras: cada caractere duplicado ou o programa completo é repetido duas vezes.

Regras:

• O código deve ser um programa ou função completo.
• As brechas padrão são proibidas.
• Métodos de E / S padrão são permitidos.
• Todos os caracteres / bytes, incluindo espaços em branco e novas linhas, são contados no comprimento do código e contribuem para os pedaços.
• Você pode assumir que a entrada e seu quadrado podem ser representados pelo tipo int / número inteiro do seu idioma.
• Você não pode assumir uma nova linha à direita ou outro caractere.
• Forneça o tamanho do seu pedaço no cabeçalho após a contagem de bytes.
• Isso é código-golfe , então programas mais curtos são melhores! Se dois programas tiverem o mesmo tamanho, vence aquele que usar o menor tamanho do pedaço. (Se você tem um programa mais longo que usa um tamanho menor de bloco, vale a pena postar também!)
• Se o seu programa exigir uma segunda entrada / linha, você não poderá fazer suposições sobre seu valor. Em particular, seu programa deve funcionar se a segunda entrada estiver vazia, igual à primeira ou um número inteiro diferente. Se o seu programa não exigir uma segunda entrada / linha, você poderá ignorar esta restrição.

Link sandbox

Perl 5 , 8 bytes (tamanho do pedaço 4)

$_*=~~+2

Experimente online ou tente a versão duplicada .

Unário ~é o negar bit a bit, então aplicá-lo duas vezes é um noop. Assim, o programa base simplesmente multiplica$_ (a variável implícita de entrada e saída) por 2.

Binário ~~é smartmatch, que retorna um booleano. ~~+2~~+2analisa como (~~+2) ~~ (+2). Como 2 é igual a 2, isso gera verdadeiro (1). Assim, o programa duplicado multiplica primeiro $_por 1, depois multiplica $_por si próprio.

05AB1E , 4 bytes (tamanho de bloco 2 ou 4)

·Inr

Experimente on-line ou dobrou como um único pedaço de 4 bytes ou dobrou como dois pedaços de 2 bytes .

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3 , 26 bytes (tamanho do pedaço 13)

lambda n:"and n*n#"and 2*n

Experimente online!

Dobrado:

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

Esta solução é fornecida pelo @Grimy.

Python 3 , 32 30 28 bytes (tamanho do pedaço 16 15 14)

lambda n:bool(0)*n*n or  2*n

Experimente online!

-4 bytes graças a @negativeSeven

Dobrado:

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

Experimente online!

A função tira proveito da regra de bloco exclusiva deste desafio.

Befunge-98 (FBBI) , 8 bytes (tamanho do bloco 2)

;&:#* +q

Experimente online!

;&;&:#:#* * +q+q

Experimente online! (dobrado)

Excluindo o fluxo de controle, o primeiro programa executa &:+q(entrada, parte superior duplicada da pilha, adiciona, sai com código de retorno) e o segundo programa &:*+q(entrada, parte superior duplicada da pilha, multiplica, adiciona (soma com um 0 implícito), sai com retorno código)

Hexagonia , 14 bytes (tamanho do pedaço 14)

?"+==*/}=+!@!<

Expandido:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

Experimente online!

Dobrado

?"+==*/}=+!@!<?"+==*/}=+!@!<

Expandido:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

Experimente dobrou online!

A hexagonia está em uma posição um pouco estranha nesse desafio, pois realmente não é muito mais difícil realizar a tarefa do que simplesmente escrever os dois programas individuais. No entanto, jogar a solução se mostrou bastante difícil.

Essa solução é a idéia trivial da forma mais curta possível, mas suspeito que haja respostas mais curtas e inteligentes. Esta versão define ingenuamente dois valores para a entrada e os soma ou multiplica, dependendo se a fonte é duplicada. A única reutilização de código é a"+ que torna o código de cópia do programa duplicado curto o suficiente para caber no espaço não utilizado do programa original.

Eu suspeito que o uso das instruções de alteração de IP []facilitará o isolamento das partes, mas uma solução realmente ideal reutilizará muito código entre as duas. Eu criei um programa auxiliar para duplicar o código fonte do hexágono. Observe que ele remove no-ops à direita; portanto, se você quiser ter no-ops no espaço reservado, basta preencher outro caractere e alterá-lo novamente depois. Ele pode lidar com diferentes tamanhos de bloco, embora eu ainda não tenha escrito código para gerar cada programa possível (o Hexagony parece se prestar ao uso do tamanho completo do bloco).

Hexagonia , 12 bytes (tamanho do bloco 4)

?"2+...}=*!@

Experimente online!

Formatado:

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

E dobrou , depois formatou:

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

Basicamente, isso define a primeira borda para a entrada e, em seguida, a segunda borda para 2uma cópia ou para uma entrada, depois multiplica essas duas bordas na terceira borda, imprime e termina. A lista de instruções executadas é apenas

?"2}=*!@

e

?"2+}=*!@

Com a única diferença sendo a +substituição 2do segundo programa.

JavaScript (ES6),  24  22 bytes

Apesar de seu formato incomum, esta é a definição de uma função anônima, que pode ser chamada diretamente ou atribuída a uma variável.

+(g=x=>x*x)?g:(x=>x*2)

Experimente online!

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

Experimente on-line dobrou!

Quão?

A aplicação do unário +a uma função é interpretada como uma tentativa de coagi-lo a um número e resulta em NaN . Portanto, o líder +(g=x=>x*x)é falso nas duas versões.

Por outro lado, aplicar o binário +entre 2 funções resulta em uma string. Portanto, (x=>x*2)+(g=x=>x*x)é verdade na versão duplicada.

Perl 6 , 8 bytes (tamanho do bloco 1)

* *<1 2>

Experimente online! Experimente dobrou!

Um lambda Whatever / HyperWhatever que pega um número e retorna um número para o primeiro programa e uma lista de singleton para o segundo programa. Basicamente, isso mantém exatamente a mesma lógica, exceto que o operador de multiplicação ( *) é substituído pelo exponencial ( **).

**  **<<11  22>>

O literal Whatever ( *duplicado também representado por a ) é dobrado para um HyperWhatever ( **) que é basicamente o mesmo, exceto que mapeia as listas. O espaço é necessário para separar o literal Whatever da multiplicação e é ignorado quando dobrado. Em vez de apenas 2(que seria dobrado para 22), usamos uma lista contendo dois elementos, que é avaliada como 2 em um contexto numérico). O <>pode ser duplicado para uma lista com interpolação, e os dois elementos internos são duplicados, mas nenhum deles altera o comprimento da lista.

Encantos Rúnicos , 9 bytes (tamanho 3)

i3?:*@:+@

Experimente online!
Experimente dobrou!

A 3?pula os próximos 3 de instruções, o que resulta em um (executado) i3?...:+@. Quando duplicado, resulta em um executado i3?...:*@onde .representa as 3 instruções NOP. @é "imprime a pilha inteira e termina".

C # (compilador interativo do Visual C #) / Javascript, 22 bytes, tamanho do pedaço 11

m=>/*      /2*m//*/m*2

Experimente online!

Brain-Flak , 48 30 bytes (tamanho do bloco 10)

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

Experimente online! Experimente dobrou!

Isso basicamente leva três etapas e, quando duplicado, executa essas etapas duas vezes cada. O programa inicial é:

1. Duplicar TOS, alternar pilhas e começar a empurrar um valor
2. Obtenha o número triangular do TOS n * (n-1) / 2
3. TOS pop, alternar pilha e pop duas vezes, em seguida, empurre o resultado.

Para uma entrada nem um programa sem problemas, isso resulta em:

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

Para o programa duplicado:

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Brain-Flak , 76 bytes, pedaços de 76 bytes

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

Experimente online!

Dobrado (com nova linha para maior clareza)

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

Experimente online!

Aqui está uma versão que usa um procedimento de duplicação mais complexo. Ele possui 5 pedaços de tamanho 15. O código aqui é de 46 bytes, no entanto, devido ao preenchimento necessário, é substancialmente mais longo.

105 90 bytes, pedaços de 15 bytes

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

Experimente online!

Duplicado (com novas linhas para maior clareza)

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

Experimente online!

Cubix , 18 14 bytes (comprimento do bloco 9 7)

*OI$|:/@O+:I. 

Observe o espaço à direita. Experimente online!

Dobrado:

*OI$|:/*OI$|:/@O+:I. @O+:I. 

Novamente, há um espaço à direita. Experimente online!

Explicação

A idéia principal é que dobrar o código faz com que o cubo fique maior, portanto o ponteiro da instrução começa com um símbolo diferente. Como o programa de adição não pode ser colocado em um cubo de comprimento lateral 1, o comprimento lateral será 2. Além disso, o código duplicado precisa estar em um cubo de comprimento lateral 3, portanto, o código duplicado deve ter pelo menos 25 bytes . Isso significa que o código deve ter pelo menos 13 bytes. Assim, é possível salvar no máximo mais 1 byte.

Agora, para o código real. A primeira observação é que a face superior (ou seja, os 4 primeiros caracteres) não é usada pelo programa de adição. Além disso, se fizermos o quinto caractere refletir o IP em torno do cubo, poderemos liberar mais 2 caracteres. Usaremos esses caracteres para colocar o programa de quadratura.

Mornington Crescent , 656 bytes (tamanho do bloco 328)

Apenas para acrescentar peso à teoria de que isso pode ser resolvido em quase qualquer idioma ...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(A nova linha à direita é importante)

Experimente a versão única! ...ou... Experimente a versão dobrada!

A teoria aqui é simples: na versão única, 'Bounds Green' é preenchido com uma sequência aleatória, mas na versão duplicada é preenchido com a entrada quadrada. Depois que o pedaço termina, ambas as versões duplicam a 'entrada', mas na versão duplicada do código, a entrada foi substituída por 0.

Esse resultado é levado de volta ao verde dos limites, que executa uma operação max () duas vezes, antes de levar o resultado à saída. Na versão única, isso mantém a duplicação inalterada (int e string são alternadas apenas para frente e para trás), mas na versão duplicada, isso substitui o 0 pelo resultado ao quadrado já armazenado em Verde Limite.

JavaScript (Node.js) , 15 12 bytes (tamanho do bloco: 6)

x=>/**/2*(x)

Experimente online!

Caso único:

x=>/**/2*(x)

Caso duplo:

x=>/**x=>/**/2*(x)/2*(x)

Parece também funcionar em C # e Java se mudar =>para ->?

R , 42 35 28 bytes (tamanho do bloco 4)

Agora com um pedaço menor e sem erros. Eu também tenho uma solução mais longa com tamanho de bloco 3; ver abaixo.

Não acho que seja possível escrever uma resposta R com tamanho de bloco 1 ou 2; Felizmente, darei uma recompensa a quem me provar errado.

s =scan#
n=s()# 
  
n/2*4#  

Experimente online!

o # é para comentários em R. A 3ª linha é apenas espaços, formando um pedaço de nova linha + 2 espaços + nova linha, para que o pedaço anterior e o próximo não tenham nova linha.

Dobrado, torna-se:

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

Experimente online!

A versão única calcula $\frac n2\times4=2n$; a versão dupla calcula$\frac n2\times \frac n2\times4=n^2$.

Aqui está uma solução um pouco mais longa, mas com tamanho de bloco 3:

R , 39 bytes (tamanho do bloco 3)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

Experimente online!

Dobrado:

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

Experimente online!

Observe que Giuseppe tem outra resposta R, com um pedaço de 30 bytes.

R , 59 30 bytes (tamanho do bloco 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

Experimente online!

Agradecemos a Robin Ryder por inspirar isso; incrementa Fcada vez e a função fseleciona a saída apropriada.

Isso não é particularmente interessante, mas sem dúvida algo inteligente manipulando o tamanho do pedaço será inventado. Como esperado, Robin Ryder propôs isso que é mais curto e tem alguma manipulação de blocos.

PowerShell , 22 bytes (tamanho do pedaço 11)

param($p)
#   /
2 * $p

Experimente online .

Dobrado:

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

Esta solução é baseada na solução da @ ShieruAsakoto .

Solução @Grimy que foi convertida no PowerShell, 26 bytes (tamanho do pedaço 13)

param($p)$t=';$p*$p#';$p*2

Experimente online .

Dobrado:

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Perl 5 ( -p), 22 15 bytes

-7 bytes graças ao Grimy

$_*=$'/4||2;//;

TIO

Carvão vegetal , 13 bytes

ＰＩ×Ｉθ⎇υＩθ²⊞υω

Experimente online! Explicação: A lista vazia predefinida é falsey, portanto a entrada é multiplicada por 2. Quando duplicada, a segunda passagem vê que a sequência vazia foi enviada à lista e, portanto, multiplica a entrada sozinha. Experimente online! Na sintaxe detalhada, isso corresponde a Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 bytes

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

Minhas habilidades em python são meio ruins, então definitivamente posso jogar golfe. Com base na resposta do Python no desafio " Eu dobro a fonte, você dobra a saída! " .

Comprimento do pedaço 53.

Experimente online ou tente online duplicou .

Java 8, 62 bytes

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Comprimento do pedaço 62.

Experimente online ou tente online dobrou .

Explicação:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

Em Java, os comentários disponíveis são // commente /* comment */. Que são combinados aqui para substituir certas partes. Veja como esses comentários funcionam graças ao destaque do Java:

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

O programa duplicado criou uma Byteclasse personalizada e seu valor SIZE=9, que substitui a java.lang.Byteclasse padrão e seu valor SIZE=8.

Japonês , 7 5 bytes

*N²jJ

Experimente | Dobrado

²empurra 2 para a matriz de entradas Ne jremove e retorna o elemento no índiceJ=-1 (isto é, o recém-inserido 2) e multiplica a entrada por isso.

Quando duplicado, resulta na Jmultiplicação de 2, portanto, o elemento no índice -2(ou seja, a entrada) é retornado je usado como multiplicador.

Gelatina , 8 6 bytes (comprimento do pedaço 3)

Ḥ;²3ị 

Experimente online!

Dobrado

Solução agradável: Lua , 66 bytes (tamanho do pedaço 66 bytes)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

Experimente online!(dobre você mesmo, não é tão difícil)

Ah, sim, tenho certeza de que há uma solução mais curta para isso, mas é o melhor que pude apresentar dessa maneira. Tome entrada como primeiro argumento.

Breve explicação: todo o negócio com aé bastante óbvio para todos, enquanto a segunda parte comx é mais interessante. Basicamente, crio uma tabela (ou atualizo uma existente na segunda passagem) com o finalizador (__gc metamétodo) que é chamado quando o programa é encerrado.

Solução coxo: Lua , 60 bytes (tamanho do bloco 30 bytes)

a=a and...^2 or ...*2;                     print(a)os.exit()

Experimente online!ou Tente dobrar!

Menor e com melhor divisão, mas enfim chato e coxo sem truques inteligentes. Tenho certeza de que nenhum comentário é necessário para este.

J , ^{15 10} 9 bytes

+: :(*-:)

Experimente online!

Versão dobrada: Experimente online!

f : gcria um verbo que é executado fquando chamado com um argumento e gquando chamado com 2 argumentos. Então o nosso executa o dobro+: da fonte original e *-:quando a fonte é duplicada.

Isso funciona porque um trem de dois verbos em J se torna um gancho e, portanto, f fé executado como y f (f y)onde y é a entrada original. Além disso, *-:ele próprio é um "gancho diádico" que funciona multiplicando* o argumento esquerdo pela metade -:do argumento direito. O arg esquerdo será a entrada original e o arg direito será a entrada duplicada, portanto, isso produzirá o quadrado da entrada original.

resposta original

J , 15 bytes

*:@]`(+:@])@.=~

Experimente online!

Versão dobrada: Experimente online!

Na versão única, temos um verbo único que usa Agenda @.para fazer a lógica if ... then: Se o argumento for igual a si mesmo=~ , pegue o argumento e dobre-o (+:@[).

No entanto, quando duplicamos o código, obtemos um gancho J. Chame o verbo fe a entrada y. Em seguida, o gancho é f fexecutado assim:

y f (f y)

O que significa que agora a entrada original é o argumento esquerdo e o argumento direito é a entrada duplicada. Como não serão iguais, =~dessa vez retornará falso, e agora executaremos a outra bifurcação da Agenda, ou seja *:@], que significa "esquadrinhar o argumento certo". E como ~inverte as entradas de um verbo diádico, o argumento certo será a entrada original.

Python 3 , 60 bytes

Chunk size 6.
Não é uma ótima solução, mas funciona. Esse é um desafio tão único que realmente faz você pensar de uma perspectiva diferente.

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

Experimente online!

Dobrado:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

Experimente online!

Cascata , 13 bytes (tamanho do pedaço 13)

]
&/2
#
*
 2&

Experimente online!

]
&/2
#
*
 2&]
&/2
#
*
 2&

Experimente dobrou!

Isso foi bem difícil. A essência básica disso é imprimir a entrada multiplicada pelo 2primeiro programa e substituir o2 por uma cópia da entrada para o segundo programa.

Explicação:

A parte executada do primeiro programa se parece com

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

O programa duplicado basicamente adiciona o primeiro ]ao final da última linha, de modo que o programa envolve isso em vez de &. Isso o transforma em

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh , 30 bytes (tamanho do pedaço 10)

m=$m[1]*2
x=$[$1$m]
return $x

Experimente online! Experimente dobrou!

Abusos o fato de que $varno $[$var]recebe expandido primeiro, então avaliada no contexto aritmética.

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

Se alguém quiser uma rachadura para diminuir isso, aqui está a 24/8solução mais próxima que eu obtive (gera x^2+2quando duplicado)