Com base em uma mensagem de bate-papo

O desafio

Dado um número de entrada n > 9, construa seu reverso, ignorando os zeros à esquerda. Em seguida, construa uma lista de todos os fatores primos que o número e seu reverso não têm em comum. Multiplique esses fatores para criar o número incomum de fator de da entrada.

Ou, em outras palavras: se rev(n)denota a reversão decimal de número inteiro n, calcule o produto de ne rev(n)dividido pelo quadrado dagcd(n, rev(n)) .

Saída esse número.

Exemplos trabalhados

Por exemplo, 2244reverte para 4422. Os fatores primos do primeiro são [2, 2, 3, 11, 17]e os fatores primos do reverso são [2, 3, 11, 67]. Os números que não estão em multiplicidades comuns são [2, 17, 67], então2278 como a saída.

Para outro exemplo, 1234reverte para 4321. O produto é 5332114e o GCD é 1, então a saída é 5332114.

Esclarecimentos adicionais

Obviamente, um número palíndrico terá todos os seus fatores em comum com o seu inverso; portanto, nesse caso, a saída é 1( n*n/n^2). Obviamente, também é possível que a saída seja a multiplicação de todos os fatores (ou seja, o gcd é 1 - a entrada e seu reverso são co-primos), como no caso do 1234exemplo.

Regras

• Supõe-se que a entrada e a saída se encaixem no tipo inteiro nativo do seu idioma.
• A entrada e saída podem ser fornecidas em qualquer formato conveniente .
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• Lacunas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 bytes

Código

‚D¿÷P

Usa a codificação 05AB1E . Experimente online!

Explicação

‚        # 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

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

Experimente online!

Como alternativa (crédito à abordagem de @ Adnan para a segunda),

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

J, 15 bytes (solução de @ miles)

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

Explicação

Essa é apenas uma implementação direta do algoritmo fornecido pelo OP.

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

Explicação, a solução @ miles

Muito esperto.

*/@(,%+.)|.&.":
         |.&.":  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&

Experimente online!

Geléia , 8 bytes

,ṚḌµ:g/P

Experimente online!

JavaScript (ES7), 67 64 bytes

Tantos bytes apenas para inverter o número :(

Recebe a entrada como uma sequência.

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

Tente

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

Experimente online!

R , 108 89 bytes

-19 bytes graças ao plannapus por seu 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}

Isso tentará alocar pelo menos um vetor de tamanho 4*nbytes (e acho que até 4); portanto, isso gerará um erro de memória para arquivos suficientemente grandes.n .

Experimente online!

Python 3 , 73 68 bytes

-5 bytes graças ao Sr. Xcoder.

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

Experimente online!

MATL , 13 12 11 bytes

tVPU*1MZdU/

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Experimente online!

Não há GCD embutido. ; -;

Casca , 10 bytes

S¤§÷o□⌋*i↔

Experimente online!

-1 graças a H.PWiz .
-1 graças a Zgarb .

Japonês , 13 12 11 bytes

sw
*V/yU ²

Tente

Explicação

Entrada implícita de número inteiro U. A linha vazia no início impede a substituição da seguinte linhaU

sw

Converta Uem uma string ( s), inverta ( w), converta novamente em um número inteiro e atribua a variável V.

*V

Multiplique Upor V.

/

Dividir.

yU

GCD de Ve U.

²

Quadrado. Saída implícita do número inteiro resultante.

Alternativa, 13 bytes

Só porque eu gosto de poder usar N.

NpUsw)mxNry)×

Tente

Pitão , 13 bytes

/*QKs_`Q^iKQ2

Experimente aqui!

Pitão , 15 bytes

Isso usa a abordagem de Adnan e recebe a entrada como uma String.

KsM_BQ*Fm/diFKK

Experimente aqui

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

A função acima calcula o "número de fator incomum" do parâmetro de entrada especificado. Após a convenção de chamada __fastcall baseada em registro , o parâmetro é passado no ECXregistro. O resultado é retornado no EAXregistro, como em todas as convenções de chamada x86.

Experimente online!

Demorou muito tempo para escrever de uma forma tão compacta, mas foi um exercício divertido. Muitas contorções para obter o agendamento de registro mais ideal possível, dentro das restrições dos DIVoperandos implícitos da instrução x86 e tentando usar codificações curtas MULe XCHGinstruções sempre que possível. Eu ficaria muito curioso para ver se alguém pode pensar em outra maneira de reduzi-lo ainda mais. Meu cérebro estava muito frito no final. Agradeça a um compilador na próxima vez que você vir um! (Embora esse seja um código muito melhor do que o que um compilador geraria ... Especialmente se você o ajustasse um pouco sem restrições de tamanho, removendo coisas assim XCHG.)

Perl 5, 72 bytes

71 bytes of code + 1 flag (-p)

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

Try it online!

Pyke, 8 bytes

_]FbP).^B

Try it here!

Takes input as a string.

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

Python 2, 70 bytes

Thanks to i cri everytim.

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

Try it online!

Python 2, 77 bytes

Note that in Python 2, you cannot use the math.gcd() method, and you must do it "by hand".

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

Try it online!

Ohm, 9 bytes

DR«D]Æ┴/µ

Try it online!

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

Try it online!