El número de factor poco común

15

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 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
AdmBorkBork
fuente
¿Podemos suponer que la entrada no tendrá ceros a la izquierda?
Sr. Xcoder
1
@ Mr.Xcoder ¿Eh? ¿Te refieres a ceros al final?
Erik the Outgolfer
@EriktheOutgolfer No, los ceros iniciales son exactamente lo que quiero decir. También
Mr. Xcoder
3
El segundo caso de prueba debería ser 1995(creo)
Sr. Xcoder
1
@LuisMendo Gracias. Buena adición
AdmBorkBork

Respuestas:

6

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
Adnan
fuente
Una alternativa agradable y simple a la fórmula proporcionada en el desafío: +1. Intenté lo mismo en Japt pero salió 2 bytes más de lo que ya tenía.
Shaggy
5

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
col
fuente
2
15 bytes con*/@(,%+.)|.&.":
millas
@miles Me encanta el truco inferior
cole
@miles que uno es realmente hábil.
Jonás
¿Por qué no enviar la versión de 15 bytes como su solución principal?
Shaggy
@ Shaggy No estoy seguro. Mi inclinación era responder con "es significativamente diferente de la mía", pero en realidad son solo dos optimizaciones. Voy a actualizarlo más tarde.
cole
3

Jalea , 8 bytes

,ṚḌµ:g/P

Pruébalo en línea!

Erik el Outgolfer
fuente
Maldición, tenía exactamente lo mismo (excepto en DUlugar de )
ETHproductions
@ETHproductions Sí, en un número entero invierte los dígitos, pero no vuelve a convertirlo en un número entero.
Erik the Outgolfer
2

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>

Lanudo
fuente
2

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!

Giuseppe
fuente
1

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
Luis Mendo
fuente
1

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

Lanudo
fuente
Truco inteligente con GCD. Creo que ese algoritmo podría ser más corto que la solución Jelly actual ...
ETHproductions
@ETHproductions In Jelly GCD termina siendo más largo ...
Erik the Outgolfer
@EriktheOutgolfer "tengo" una versión de 8 bytes, pero esto implica dividir los resultados de dos díadas y no estoy seguro de cómo hacerlo correctamente ...
ETHproductions
1

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 ).

Cody Gray
fuente
0

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!

Xcali
fuente
0

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(^)
Azul
fuente
0

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!

Sr. Xcoder
fuente
Python 3 tiene gcdcomo fractions.gcd.
Totalmente humano
@icrieverytim Por eso elegí resolverlo en Python 2.
Sr. Xcoder
... Vaya, quise decir Python 2. Python 3 tiene math.gcd.
totalmente humano
@icrieverytim hecho.
Sr. Xcoder
0

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!

Roberto Graham
fuente
1
En el ciclo while, puede reemplazar t!=0por t>0, ya que t nunca será negativo. f*r/(i*i)es el mismo que f/i*r/i. Puede soltar f=t;y r=i;si encadena la asignación de iy t.
Lucas
1
El ciclo while se puede escribir como while(t>0)t=i%(i=t);(-11 bytes).
Nevay