Basé sur un message de chat

Le défi

Étant donné un numéro d'entrée n > 9, construisez son inverse, en ignorant les zéros de tête. Ensuite, construisez une liste de tous les facteurs premiers que le nombre et son inverse n'ont pas en commun. Multipliez ces facteurs ensemble pour créer le numéro de facteur rare de l'entrée.

Ou, pour le dire autrement: si rev(n)dénote l'inversion décimale d'un entier n, calculez le produit de net rev(n)divisé par le carré de gcd(n, rev(n)).

Sortez ce nombre.

Exemples travaillés

Par exemple, passe 2244à 4422. Les facteurs premiers du premier sont [2, 2, 3, 11, 17]les facteurs premiers de l'inverse [2, 3, 11, 67]. Les nombres qui ne sont pas dans des multiplicités communes le sont [2, 17, 67], tout 2278comme la sortie.

Pour un autre exemple, 1234inverse à 4321. Le produit est 5332114et le GCD est 1, donc la sortie est 5332114.

Précisions supplémentaires

Évidemment, un nombre palindromique aura tous ses facteurs en commun avec son inverse, donc dans un tel cas, la sortie est 1( n*n/n^2). De toute évidence, il est également possible que la sortie soit la multiplication de tous les facteurs (c'est-à-dire que le pgcd est 1 - l'entrée et son inverse sont co-amorces), comme dans le cas de l' 1234exemple.

Règles

• L'entrée et la sortie peuvent être supposées correspondre au type d'entier natif de votre langue.
• L'entrée et la sortie peuvent être données dans n'importe quel format pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 octets

Code

‚D¿÷P

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Alternativement (crédit à l'approche de @ Adnan pour la seconde),

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

J, 15 octets (solution de @ miles)

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

Explication

Ceci est juste une implémentation simple de l'algorithme donné par l'OP.

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

Explication, la solution de @ miles

Très intelligent.

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

Mathematica, 33 octets

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

Essayez-le en ligne!

Gelée , 8 octets

,ṚḌµ:g/P

Essayez-le en ligne!

JavaScript (ES7), 67 64 octets

Tant d'octets juste pour inverser le nombre :(

Prend l'entrée sous forme de chaîne.

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

Essayez-le

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 octets

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

Essayez-le en ligne!

R , 108 89 octets

-19 octets grâce à plannapus pour son algorithme 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}

Cela tentera d'allouer au moins un vecteur d' 4*noctets de taille (et je pense que jusqu'à 4), donc cela générera une erreur de mémoire pour suffisamment grand n.

Essayez-le en ligne!

Python 3 , 73 68 octets

-5 octets grâce à M. Xcoder.

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

Essayez-le en ligne!

MATL , 13 12 11 octets

tVPU*1MZdU/

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Essayez-le en ligne!

Pas de GCD intégré. ; -;

Husk , 10 octets

S¤§÷o□⌋*i↔

Essayez-le en ligne!

-1 merci à H.PWiz .
-1 merci à Zgarb .

Japt , 13 12 11 octets

sw
*V/yU ²

Essayez-le

Explication

Saisie implicite d'entier U. La ligne vide au début, empêche la ligne suivante d'écraserU

sw

Convertissez-le Uen chaîne ( s), inversez-le ( w), reconvertissez-le en entier et attribuez-le à une variable V.

*V

Multipliez Upar V.

/

Diviser.

yU

GCD de Vet U.

²

Au carré. Sortie implicite de l'entier résultant.

Alternative, 13 octets

Tout simplement parce que j'aime pouvoir utiliser N.

NpUsw)mxNry)×

Essayez-le

Pyth , 13 octets

/*QKs_`Q^iKQ2

Essayez-le ici!

Pyth , 15 octets

Cela utilise l'approche d'Adnan et prend l'entrée comme une chaîne.

KsM_BQ*Fm/diFKK

Essayez-le ici

Code machine x86, 39 octets

;;; 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 fonction ci-dessus calcule le "nombre de facteurs rares" du paramètre d'entrée spécifié. Suite à la convention d'appel __fastcall basée sur le registre , le paramètre est passé dans le ECXregistre. Le résultat est renvoyé dans le EAXregistre, comme avec toutes les conventions d'appel x86.

Essayez-le en ligne!

Cela a pris énormément de temps pour écrire sous une forme aussi compacte, mais c'était un exercice amusant. Beaucoup de contorsions pour obtenir la planification de registre la plus optimale possible, dans les limites des DIVopérandes implicites de l' instruction x86 et en essayant d'utiliser des encodages courts MULet des XCHGinstructions dans la mesure du possible. Je serais très curieux de voir si quelqu'un peut penser à une autre façon de la raccourcir davantage. Mon cerveau était assez frit à la fin. Remerciez un compilateur la prochaine fois que vous en verrez un! (Bien que ce soit moyen de code mieux que ce compilateur générerait ... Surtout si vous peaufiné légèrement sans contraintes de taille, la suppression des choses comme XCHG.)

Perl 5 , 72 octets

71 octets de code + 1 indicateur ( -p)

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

Essayez-le en ligne!

Pyke , 8 octets

_]FbP).^B

Essayez-le ici!

Prend l'entrée sous forme de chaîne.

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

Python 2 , 70 octets

Merci à i cri everytim .

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

Essayez-le en ligne!

Python 2 , 77 octets

Notez qu'en Python 2, vous ne pouvez pas utiliser la math.gcd()méthode et vous devez le faire "à la main".

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

Essayez-le en ligne!

Ohm , 9 octets

DR«D]Æ┴/µ

Essayez-le en ligne!

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

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

Essayez-le en ligne!