Desafio:

Há um quebra-cabeça bobo circulando nas redes sociais que diz:

8 + 2 = 16106
5 + 4 = 2091
9 + 6 = ?

Implementar uma função ou um operador que, quando dada dois números inteiros positivos xe yde tal modo que x > y > 0, produz a resposta correcta como um número inteiro , em que a resposta é dígitos são os dígitos de x * yseguindo-se os dígitos de x + yseguindo-se os dígitos de x - y. Muito simples.

Regras:

• As brechas padrão não são permitidas.
• Este é o código-golfe, pelo que o código mais curto em bytes vence.
• A validação de dados de entrada não é necessária. Este programa pode falhar ou retornar lixo quando receber uma entrada inválida.
• Você tem permissão para usar funções e operadores numéricos (incluindo número inteiro e ponto flutuante, funções da biblioteca matemática e outras funções que aceitam e retornam números).
• Você tem permissão para usar uma função que retorna o número de dígitos de um número, se aplicável.
• Você não tem permissão para usar strings ou qualquer tipo de concatenação em qualquer lugar do seu código.
• O resultado pode ser retornado ou enviado para a pilha, o que se aplica no idioma. O resultado deve ser um número inteiro, não uma sequência.

Código de amostra:

Dyalog APL :

O código a seguir cria um operador diádico chamado X.

X ← {(⍺-⍵) + ((⍺ + ⍵) × 10 * 1 + ⌊10⍟⍺-⍵) + ⍺ × ⍵ × 10 * (2 + ⌊10⍟⍺ + ⍵) + ⌊10⍟⍺- ⍵}

Explicação:

• No APL, você avalia da direita para a esquerda.

• ⍺ and ⍵ são o operando esquerdo e direito, respectivamente

• ⌊10⍟⍺-⍵lê-se: floor of log10(⍺-⍵). Primeiro executa a subtração, depois o logaritmo e o piso. Da direita para esquerda. log10 é feito para contar os dígitos de ⍺-⍵(você deve somar 1 depois).

• ⍺×⍵×10*(...) lê: 10 to the (...)th power, multiplied by ⍵, multiplied by ⍺

• Portanto, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵é o produto, deslocado para a esquerda pela soma do número de dígitos da soma e a diferença. A multiplicação por uma potência de 10 deslocará um número inteiro para a esquerda.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) é a soma, deslocada para a esquerda pelo número de dígitos da diferença.

• (⍺-⍵)é a diferença Nenhuma mudança é necessária aqui.

• X←{...} é assim que você define um operador no APL.

Exemplos:

      8 X 2
16106
      5 X 4
2091
      9 X 6
54153

GNU dc:

O código a seguir cria uma macro chamada a:

[sysx10lxly-dseZdsclxly+dsd+Z1+^lxly**10lc^ld*+le+]sa

Explicação:

• sxe sypop um elemento da pilha e salve-o nos registradores xe y, respectivamente.

• lxe lycarregue um elemento dos registradores xe, yrespectivamente, e empurre-o para a pilha.

• d duplica o último elemento na pilha.

• ^ calcula a potência de dois números.

• Zaparece um número e retorna seu número de dígitos. Isso é feito porque dcnão possui função de logaritmo.

• [...]saarmazena uma macro no registro a. lacarrega. xexecuta a macro na parte superior da pilha.

Exemplos:

8 2 laxn
16106
5 4 laxn
2091
9 6 laxn
54153

JavaScript (ES7), 63 61 59 bytes

Economizou 4 bytes graças a Neil .

(a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c)

<input id=a type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c))(+a.value,+b.value)">
<input id=b type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-!Math.log10(c)+c))(+a.value,+b.value)">
<p id=c>

C, 79 75 bytes

Obrigado a @GB por economizar 4 bytes!

#define X for(c=1;(c*=10)<=a
c,d;f(a,b){X+b;);d=c*a*b+a+b;X-b;);a=d*c+a-b;}

Experimente online!

Bash, 66

• 2 bytes salvos graças ao @chepner.

f()(s=$[$1+$2]
d=$[$1-$2]
echo $[($1*$2*10**${#s}+s)*10**${#d}+d])

Experimente online .

EXCEL, 61 bytes

=A1-B1+(A1+B1)*10^LEN(A1-B1)+A1*B1*10^(LEN(A1-B1)+LEN(A1+B1))

Excel, 18 bytes inválidos

=A1*B1&A1+B1&A1-B1

Empilhados , 36 bytes

,@A$(*+-){!A...n!}"!{%y#'10\^x*y+}#\

Experimente online!

Anteriormente: ,@A$(-+*){!A...n!}"!:inits$#'"!$summap:pop@.10\^1\,\*sum

Vou tentar extrair um byte ou dois antes de escrever uma explicação. ( #'= tamanho de e "é "faça em cada", nenhuma string anexada aqui.)

Não concorrentes em 26 bytes: $(*+-)#!!:{%y#'10\^x*y+}#\.

TI-Basic, 34 33 bytes

Prompt A,B
A-B+(A+B)10^(1+int(log(A-B
Ans+AB10^(1+int(log(Ans

GNU dc, 36

Define uma macro mque pega os dois principais membros da pilha, aplica a macro e deixa o resultado na pilha (conforme o exemplo na pergunta):

[sadsbla-dZAr^lalb+*+dZAr^lalb**+]sm

Experimente online .

Perl 6 ,  81 61  58 bytes

->\x,\y{($/=($/=x- y)+(x+y)*({10**$++}...*>$/).tail)+x*y*({10**$++}...*>$/).tail}

Tente

->\x,\y{(x*y,x+y,x- y).reduce:{$^a*10**Int(1+log10($^b))+$b}}

Tente

->\x,\y{[[&({$^a*10**Int(1+$^b.log10)+$b})]] x*y,x+y,x- y}

Tente

Gelatina , 27 bytes

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵*
ạ,+,×Fæ.ç

Define um link / função diádico, que pode ser chamado com ç. Pega dois números inteiros como entrada e retorna um número inteiro. Ele tem o bônus adicional de poder aceitar x <y ou x >y usando a diferença absoluta.

Experimente online!

Explicação:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create link which computes what order of magnitude
                        to multiply the difference, sum, and product by
ạ,+,×Fæ.ç         -- Main link, applies this using dot product

Detalhes:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create dyadic like which does the following:
       l⁵Ḟ‘       -- Create operation which computes number of digits
                       (log base 10 (⁵ is the literal 10), floored, incremented)
           €      -- Apply this to each element in
+,ạ,.1F           -- ... the list [sum,difference,.1]
            R     -- Reverse the list
             +\   -- Add up first n elements to get list.
               ⁵* -- Raise 10 (⁵ is literal 10) to the power of each element

ạ,+,×Fæ.ç         -- Main link, applies above link
ạ,+,×F            -- The list [difference, sum, product]
      æ.          -- Dot product (multiply corresponding elements) with
        ç         -- The above link.

PHP, 79 75 bytes

duas versões:

[,$a,$b]=$argv;echo(10**strlen($s=$a+$b)*$a*$b+$s)*10**strlen($d=$a-$b)+$d;
[,$a,$b]=$argv;echo(10**strlen($a+$b)*$a*$b+$a+$b)*10**strlen($a-$b)+$a-$b;

recebe entrada de argumentos de linha de comando; corra com -r.

Eu acho que se strlenqualifica como "função que retorna o número de dígitos",
embora use o número como uma string. Deixe-me saber se não.

C (gcc) , 70 bytes

#define _ for(c=1;a+b>=(c*=10););d=c*d+a-(b=-b);
c,d;f(a,b){d=a*b;_ _}

Experimente online!

com base na resposta do Steadybox , colocando tudo em uma macro para jogar um pouco mais.

(Nota: atribuir o resultado ao dinvés de afuncionar, inesperadamente. Dei uma olhada no código do assembly gerado e ele parece estar ok.)

Haskell, 54 bytes

a%0=a
a%b=10*a%div b 10+mod b 10
a#b=(a*b)%(a+b)%(a-b)

O quebra-cabeça é implementado através de uma função infix #, por exemplo 8#2 = 16106. A outra função, %define a concatenação da base 10 (assumindo que o RHS seja maior que 0).

Dyalog APL, 31 bytes

{a⊥⍨10*1+⌊10⍟a←(⍺×⍵)(⍺+⍵)(⍺-⍵)}

com base no código APL de amostra da declaração do problema

PHP, 87 bytes

[,$a,$b]=$argv;echo($s=$a-$b)+($t=$a+$b)*10**($l=strlen($s))+$a*$b*10**($l+strlen($t));

e uma solução não válida para 37 bytes

[,$a,$b]=$argv;echo$a*$b,$a+$b,$a-$b;

Ruby, 61 bytes

->a,b{[a*b,a+b,a-b].reduce{|x,y|z=y;x*=10while(z>z/=10);x+y}}

O que suspeita se parece muito com esta resposta Javascript, mas sem usar um logaritmo.

Python, 92 91 caracteres

def g(x,y):
    l=lambda x,i=0:l(x/10,i+1)if x else 10**i
    a=x-y
    a+=(x+y)*l(a)
    return x*y*l(a)+a

Graças à sugestão do Wizards;)

R (3.3.1), 104 bytes

function(x,y)Reduce(function(p,q)p*10^(floor(log10(q)+1))+q,lapply(c(`*`,`+`,`-`),function(z)z(x,y)),0)

retorna uma função anônima.

Esta é minha primeira tentativa de golfe, então qualquer feedback é apreciado.

REXX, 70 bytes

f:arg a b
c=a-b
c=(a+b)*10**length(c)+c
c=a*b*10**length(c)+c
return c

Obviamente, a maneira nativa seria muito mais curta:

f:arg a b
return a*b||a+b||a-b

PowerShell, 88 bytes

param($x,$y)$l=2;if(($a=$x+$y)-gt9){$l++};($x*$y)*[math]::Pow(10,$l)+$a*10+$x-$y

O PowerShell não possui um para o operador de energia, o que não ajuda. Também não podemos contar o comprimento de um número inteiro, a menos que você o conte como uma string, o que não podemos fazer, por isso, verifico se é -gt9 para saber o comprimento. Provavelmente poderia ser mais conciso, mas tenho que voltar ao trabalho.

Python 2.7, 109 96 bytes

import math
a=lambda n:10**int(math.log10(10*n))
b,c=input()
d=b-c+(b+c)*a(b-c)
print d+b*c*a(d)

Corrigido após seguir as regras do concurso. Créditos ao mbomb007 por reduzir o código de 109 bytes para 96 bytes

J , 25 bytes

X=.10#.[:;10#.inv&.>*;+;-

1. *;+;- Caixa os resultados de cada operação.
2. 10#.inv&.>Converta cada resultado em uma matriz de dígitos de base 10. ( invé ^:_1)
3. [:; Desmarque e junte-se às matrizes.
4. 10#. Converta a matriz de dígitos da base 10 em um número inteiro.
5. X=.defina o acima como o operador X.

Resultados:

   8 X 2
16106
   5 X 4
2091
   9 X 6
54153

Mathematica, 67 bytes

c=Ceiling;l=Log10;#-#2+(#+#2)10^(c@l[#-#2]/. 0->1)+10^c@l[2#]10#2#&

Pega x-y, pega o log10 de x-y, arredonda-o, calcula 10 à potência disso e multiplica-o por x+y. Mas também precisamos considerar log10(x-y)0, então substituímos 0 por 1. Então pegamos o log10 de 2x, arredondado para cima, mais 1, e encontramos 10 ao poder disso. Multiplique por xye adicione.

05AB1E , 23 22 16 bytes

-Dg°¹²+*Dg°¹²**O

Experimente online!

Poderíamos ter salvo alguns bytes se tivéssemos permissão para usar seqüências de caracteres no programa (mas não nos cálculos) fazendo um loop sobre uma sequência contendo as operações "-+*", pois o código executado para cada operação é o mesmo.
Obviamente, se tivéssemos permissão para usar a concatenação, teríamos economizado muito mais.

R, 64 bytes

x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)

Uso:

> x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)
1: 8 2
3: 
Read 2 items
[1] 16106