Reto:

Hay un rompecabezas tonto que circula en las redes sociales que dice:

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

Implemente una función u operador que, cuando se le dan dos números enteros positivos xy de ymodo que x > y > 0, arroje la respuesta correcta como un entero , donde los dígitos de la respuesta son los dígitos x * yseguidos por los dígitos x + yseguidos por los dígitos de x - y. Muy simple.

Reglas:

• Las lagunas estándar no están permitidas.
• Este es el código de golf, por lo que el código más corto en bytes gana.
• No se requiere validación de datos de entrada . Este programa puede bloquearse o devolver basura cuando se le da una entrada no válida.
• Puede utilizar funciones y operadores numéricos (incluidos números enteros y coma flotante, funciones de biblioteca matemática y otras funciones que aceptan y devuelven números).
• Puede usar una función que devuelve el número de dígitos de un número, si corresponde.
• Estas no permitido el uso de cadenas o cualquier tipo de concatenación en cualquier lugar en el código.
• El resultado puede devolverse o enviarse a la pila, lo que corresponda en el idioma. El resultado debe ser un número entero, no una cadena.

Código de muestra:

Dyalog APL :

El siguiente código crea un operador diádico llamado X.

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

Explicación:

• En APL, evalúa de derecha a izquierda.

• ⍺ and ⍵ son el operando izquierdo y derecho, respectivamente

• ⌊10⍟⍺-⍵dice lo siguiente: floor of log10(⍺-⍵). Primero realiza la resta, luego el logaritmo y luego el piso. De derecha a izquierda. log10 se realiza para contar los dígitos de ⍺-⍵(debe sumar 1 después).

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

• Por lo tanto, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵es el producto, desplazado hacia la izquierda por la suma del número de dígitos de la suma y la diferencia. Multiplicar por una potencia de 10 desplazará un número entero a la izquierda.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) es la suma, desplazada a la izquierda por el número de dígitos de la diferencia.

• (⍺-⍵)es la diferencia No se necesitan cambios aquí.

• X←{...} es cómo define un operador en APL.

Ejemplos:

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

GNU dc:

El siguiente código crea una macro llamada a:

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

Explicación:

• sxy sypop un elemento de la pila y guárdelo en los registros xy y, respectivamente.

• lxy lycargar un elemento de registros xy yrespectivamente y empujarlo a la pila.

• d duplica el último elemento en la pila.

• ^ calcula el poder de dos números.

• Zmuestra un número y devuelve su número de dígitos. Esto se hace porque dcno tiene función de logaritmo.

• [...]saalmacena una macro en el registro a. lalo carga xejecuta la macro en la parte superior de la pila.

Ejemplos:

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

JavaScript (ES7), 63 61 59 bytes

Guardado 4 bytes gracias 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

¡Gracias a @GB por guardar 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;}

Pruébalo en línea!

Bash, 66

• 2 bytes guardados gracias a @chepner.

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

Pruébalo en línea .

EXCEL, 61 Bytes

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

Excel, 18 bytes no válidos

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

Apilado , 36 bytes

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

Pruébalo en línea!

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

Voy a tratar de extraer un byte o dos antes de escribir una explicación. ( #'= tamaño de, y "es "hacer en cada uno", sin condiciones adjuntas aquí.)

Que no compiten en 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 una macro mque toma los dos miembros superiores de la pila, aplica la macro y deja el resultado en la pila (según el ejemplo en la pregunta):

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

Pruébalo en línea .

Perl 6 ,  81 61  58 bytes

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

Intentalo

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

Intentalo

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

Intentalo

Jalea , 27 bytes

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

Define un enlace / función diádica, invocable con ç. Toma dos enteros como entrada y devuelve un entero. Tiene la ventaja adicional de poder tomar x <y o x >y usando la diferencia absoluta.

Pruébalo en línea!

Explicación:

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

Detalles:

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

dos versiones:

[,$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;

toma datos de los argumentos de la línea de comandos; correr con -r.

Supongo que strlencalifica como "función que devuelve el número de dígitos",
aunque usa el número como una cadena. Avísame si no.

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;_ _}

Pruébalo en línea!

basado en la respuesta de Steadybox , poniendo todo en una macro para jugar golf un poco más.

(Nota: asignar el resultado en dlugar de atrabajos, inesperadamente. Eché un vistazo al código de ensamblaje generado y parece estar bien).

Haskell, 54 bytes

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

El rompecabezas se implementa mediante una función infija #, por ejemplo 8#2 = 16106. La otra función, %define la concatenación de base 10 (suponiendo que el RHS es mayor que 0).

Dyalog APL, 31 bytes

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

basado en el código APL de muestra de la declaración del problema

PHP, 87 bytes

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

y una solución no 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}}

Que sospechosamente se parece mucho a esta respuesta Javascript, pero sin usar un 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

Gracias a la sugerencia de 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)

devuelve una función anónima

Este es mi primer intento de golf, por lo que cualquier comentario es 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

Por supuesto, la forma nativa sería mucho más corta:

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

PowerShell no tiene un operador de energía que no ayuda. Tampoco puedo contar la longitud de un entero a menos que lo cuentes como una cadena, lo que no podemos hacer, así que verifico si es -gt9 para conocer la longitud. Probablemente podría ser más conciso, pero tengo que volver al trabajo.

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)

Corregido después de seguir las reglas del concurso. Créditos a mbomb007 por bajar el código de 109 bytes a 96 bytes

J , 25 bytes

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

1. *;+;- Encajona los resultados de cada operación.
2. 10#.inv&.>Convierta cada resultado en una matriz de dígitos de base 10. ( inves ^:_1)
3. [:; Desempaquete y únase a las matrices.
4. 10#. Convierta una matriz de dígitos de base 10 en un número entero.
5. X=.define lo anterior como el 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#&

Toma x-y, luego toma el log10 de x-y, lo redondea, calcula 10 a la potencia de eso y luego lo multiplica por x+y. Pero también debemos considerar log10(x-y)ser 0, por lo que reemplazamos 0 con 1. Luego tomamos el log10 de 2x, redondeado, más 1, y encontramos 10 a la potencia de eso. Multiplique eso por xyy agréguelo.

05AB1E , 23 22 16 bytes

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

Pruébalo en línea!

Podríamos haber guardado unos pocos bytes si nos hubieran permitido usar cadenas en el programa (pero no en los cálculos) haciendo un bucle sobre una cadena que contiene las operaciones "-+*", ya que el código realizado para cada operación es el mismo.
Por supuesto, si se nos hubiera permitido usar la concatenación, habríamos ahorrado mucho más.

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