Basado en un mensaje de chat

El reto

Dado un número de entrada n > 9, construya su reverso, ignorando los ceros iniciales. Luego, construya una lista de todos los factores primos que el número y su reverso no tienen en común. Multiplique esos factores para crear el Número de factor poco común de la entrada.

O, para decirlo de otra manera: si rev(n)denota la inversión decimal del número entero n, calcule el producto de ny rev(n)dividido por el cuadrado de gcd(n, rev(n)).

Salida de ese número.

Ejemplos trabajados

Por ejemplo, 2244revierte a 4422. Los factores primos del primero son [2, 2, 3, 11, 17]y los factores primos del reverso son [2, 3, 11, 67]. Los números que no están en multiplicidades comunes son [2, 17, 67], también lo 2278es la salida.

Para otro ejemplo, 1234revierte a 4321. El producto es 5332114y el GCD es 1, por lo que la salida es 5332114.

Aclaraciones adicionales

Obviamente, un número palindrómico tendrá todos sus factores en común con su inverso, por lo que en tal caso la salida es 1( n*n/n^2). Obviamente, también es posible que la salida sea la multiplicación de todos los factores (es decir, el mcd es 1 - la entrada y su reverso son co-primos), como en el caso del 1234ejemplo.

Reglas

• Se puede suponer que la entrada y la salida se ajustan al tipo de entero nativo de su idioma.
• La entrada y la salida se pueden dar en cualquier formato conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 bytes

Código

‚D¿÷P

Utiliza el 05AB1E codificación . Pruébalo en línea!

Explicación

‚        # Get the array [input, reversed(input)]
  D       # Duplicate that array
   ¿      # Calculate the GCD of the array
    ÷     # Divide each element in the array by the GCD
     P    # Product of that array

J, 18 bytes

".@|.@":(*%*:@+.)]

Pruébalo en línea!

Alternativamente (crédito al enfoque de @ Adnan para el segundo),

".@|.@":(*%2^~+.)]
".@|.@":*/@(,%+.)]

J, 15 bytes (solución de @ miles)

*/@(,%+.)|.&.":

Explicación

Esta es solo una implementación sencilla del algoritmo proporcionado por el OP.

".@|.@":(*%*:@+.)]
                 ]  n (input)
".@|.@":            n reversed
         *          Product of the two
          %         Divided by
              +.      GCD
           *:         Squared

Explicación, la solución de @ miles

Muy inteligente.

*/@(,%+.)|.&.":
         |.&.":  Reverse digits
           &.":   Convert to string, apply next function, and undo conversion
         |.       Reverse
   (,%+.)        Divide n and reverse(n) by GCD of both
*/               Product

Mathematica, 33 bytes

#(s=IntegerReverse@#)/GCD[#,s]^2&

Pruébalo en línea!

Jalea , 8 bytes

,ṚḌµ:g/P

Pruébalo en línea!

JavaScript (ES7), 67 64 bytes

Tantos bytes solo para invertir el número :(

Toma la entrada como una cadena.

n=>n*(x=[...n].reverse().join``)/(g=(y,z)=>z?g(z,y%z):y)(n,x)**2

Intentalo

o.innerText=(f=
n=>n*(x=[...n].reverse().join``)/(g=(y,z)=>z?g(z,y%z):y)(n,x)**2
)(i.value="10");oninput=_=>o.innerText=f(i.value)

<input id=i min=10 type=number><pre id=o>

Haskell, 44 bytes

f x|r<-read$reverse$show x=x*r`div`gcd x r^2

Pruébalo en línea!

R , 108 89 bytes

-19 bytes gracias a plannapus por su algoritmo gcd

function(n){k=1:nchar(n)-1
q=1:n
(r=sum(n%/%10^k%%10*10^rev(k)))*n/max(q[!r%%q&!n%%q])^2}

Esto intentará asignar al menos un vector de 4*nbytes de tamaño (y creo que hasta 4), por lo que arrojará un error de memoria para suficientemente granden .

Pruébalo en línea!

Python 3 , 73 68 bytes

-5 bytes gracias al Sr. Xcoder.

import math
def f(n):g=int(str(n)[::-1]);print(n*g/math.gcd(n,g)**2)

Pruébalo en línea!

MATL , 13 12 11 bytes

tVPU*1MZdU/

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

t      % Imoplicit input: number. Duplicate
VPU    % String representation, flip, evaluate. This reverses digits
*      % Multiply input and reversed-digit version
1M     % Push the input and reversed-digit version again
Zd     % Greatest common divisor
U      % Square
/      % Divide. Implicit display

Neim , 11 bytes

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Pruébalo en línea!

Sin GCD incorporado. ; -;

Casco , 10 bytes

S¤§÷o□⌋*i↔

Pruébalo en línea!

-1 gracias a H.PWiz .
-1 gracias a Zgarb .

Japt , 13 12 11 bytes

sw
*V/yU ²

Intentalo

Explicación

Entrada implícita de entero U. La línea vacía al principio evita que la siguiente línea se sobrescribaU

sw

Convierte Ua una cadena ( s), inviértela ( w), vuelve a convertir a un entero y asigna a variable V.

*V

Multiplicar Upor V.

/

Dividir.

yU

MCD de Vy U.

²

Cuadrado Salida implícita del entero resultante.

Alternativa, 13 bytes

Solo porque me gusta poder usar N.

NpUsw)mxNry)×

Intentalo

Pyth , 13 bytes

/*QKs_`Q^iKQ2

Pruébalo aquí!

Pyth , 15 bytes

Esto utiliza el enfoque de Adnan y toma la entrada como una cadena.

KsM_BQ*Fm/diFKK

Pruébalo aquí

Código de máquina x86, 39 bytes

;;; Obtain a "reversed" version of the input value.
;;; 
;;; To do this, each iteration of a loop, we take the input value modulo 10,
;;; add that to our accumulator (EDI), multiply the accumulator by 10, and
;;; divide the input value by 10. x86's DIV instruction does both modulo and
;;; division as a single operation, with the cost of clobbering two output
;;; registers (EAX and EDX). We clobber the input value throughout the loop
;;; (the way we know we're done is when it becomes 0---that means that we have
;;; pulled all of the digits off of it), so we need to save a copy of it first.
89 C8           mov    eax, ecx     ; make copy of input
31 FF           xor    edi, edi     ; clear accumulator
6A 0A           push   10
5E              pop    esi          ; set ESI to 10
             Reverse:
0F AF FE        imul   edi, esi     ; accumulator *= 10
99              cdq                 ; zero EDX in preparation for division
F7 F6           div    esi          ; EDX:EAX / 10 (EAX is quot, EDX is rem)
01 D7           add    edi, edx     ; accumulator += remainder
85 C0           test   eax, eax     ; was quotient 0?
75 F4           jnz    Reverse      ; if not, keep looping and extracting digits

;;; At this point, EAX is 0 (clobbered throughout the loop),
;;; ECX still contains a copy of our original input, and
;;; EDI contains the 'reversed' input.
89 C8           mov    eax, ecx     ; make another copy of the input
F7 E7           mul    edi          ; multiply input (implicit EAX operand)
                                    ;  by 'reversed', with result in EDX:EAX
                                    ;  (note: EDX will be 0)

;;; Compute the greatest common denominator (GCD) of the input and
;;; the 'reversed' values, using a subtraction-based algorithm.
             GCD_0:
39 CF           cmp    edi, ecx     ; compare the two values
72 02           jb     GCD_1        ; go to GCD_1 if less than
87 F9           xchg   ecx, edi     ; swap values
             GCD_1:
29 F9           sub    ecx, edi     ; subtract
75 F6           jnz    GCD_0        ; if sum != 0, go back to the top

;;; Square the GCD.
0F AF FF        imul   edi, edi

;;; Divide the product of input and 'reversed' by the square of the GCD.
;;; Remember from above that the product of input and 'reversed' is in
;;; the EAX register, and we can assume EDX is 0, so we don't need to do
;;; a CDQ here in preparation for the division. Using EAX as the implicit
;;; source operand saves us a byte when encoding DIV.
F7 F7           div    edi

;;; The DIV instruction placed the quotient in EAX,
;;; which is what we want to return to the caller.
C3              ret

La función anterior calcula el "número de factor poco común" del parámetro de entrada especificado. Siguiendo la convención de llamada __fastcall basada en el ECXregistro , el parámetro se pasa en el registro. El resultado se devuelve en elEAX registro, como con todas las convenciones de llamadas x86.

Pruébalo en línea!

Tomó mucho tiempo escribir en una forma tan compacta, pero fue un ejercicio divertido. Muchas contorsiones para obtener la programación de registro más óptima posible, dentro de las restricciones de los DIVoperandos implícitos de la instrucción x86 y tratando de usar codificaciones cortas de MULyXCHG instrucciones siempre que sea posible. Me daría mucha curiosidad ver si alguien puede pensar en otra forma de acortarlo aún más. Mi cerebro estaba bastante frito al final. ¡Agradezca a un compilador la próxima vez que vea uno! (Aunque este es un código mucho mejor que el que generaría un compilador ... Especialmente si lo modifica un poco sin restricciones de tamaño, eliminando cosas comoXCHG ).

Perl 5 , 72 bytes

71 bytes de código + 1 bandera ( -p)

$t=$_*($b=reverse);($_,$b)=(abs$_-$b,$_>$b?$b:$_)while$_-$b;$_=$t/$_**2

Pruébalo en línea!

Pyke , 8 bytes

_]FbP).^B

Pruébalo aquí!

Toma la entrada como una cadena.

_         -    reversed(input)
 ]        -   [^, input]
  FbP)    -  for i in ^:
   b      -     int(^)
    P     -    factors(^)
      .^  -  xor_seq(^)
        B - product(^)

Python 2 , 70 bytes

Gracias a i cri everytim .

def f(n):g=int(`n`[::-1]);print n*g/gcd(n,g)**2
from fractions import*

Pruébalo en línea!

Python 2 , 77 bytes

Tenga en cuenta que en Python 2, no puede usar el math.gcd()método, y debe hacerlo "a mano".

y=lambda a,b:b and y(b,a%b)or a
def f(n):g=int(`n`[::-1]);print n*g/y(n,g)**2

Pruébalo en línea!

Ohm , 9 bytes

DR«D]Æ┴/µ

Pruébalo en línea!

Java 8, 158 , 150, 148, 138, 125, 123 116 107 + 19 bytes

i->{int o,r,f,t=f=i;i=r=i.valueOf(""+new StringBuffer(t+"").reverse());while(t>0)t=i%(i=t);return f/i*r/i;}

Pruébalo en línea!