Basato su un messaggio di chat

La sfida

Dato un numero di input n > 9, costruisci il suo contrario, ignorando gli zeri iniziali. Quindi, costruisci un elenco di tutti i fattori primi che il numero e il suo contrario non hanno in comune. Moltiplicare insieme questi fattori per creare il Numero di fattore non comune dell'input.

Oppure, per dirla in altro modo: se rev(n)indica l'inversione decimale dell'intero n, calcola il prodotto di ne rev(n)diviso per il quadrato di gcd(n, rev(n)).

Emetti quel numero.

Esempi lavorati

Ad esempio, 2244inverte a 4422. I fattori primi del primo sono [2, 2, 3, 11, 17]e i fattori primi del contrario sono [2, 3, 11, 67]. I numeri non nelle comuni molteplicità sono [2, 17, 67], così 2278come l'output.

Per un altro esempio, 1234ripristina 4321. Il prodotto è 5332114e il GCD è 1, quindi l'uscita è 5332114.

Ulteriori chiarimenti

Ovviamente un numero palindromico avrà tutti i suoi fattori in comune con il suo contrario, quindi in tal caso l'output è 1( n*n/n^2). Ovviamente, è anche possibile che l'output sia la moltiplicazione di tutti i fattori (vale a dire, gcd è 1 - l'input e il suo contrario sono co-prime), come nel caso 1234dell'esempio.

Regole

• Si presume che l'input e l'output si adattino al tipo intero nativo della tua lingua.
• L'input e l'output possono essere forniti in qualsiasi formato conveniente .
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 byte

Codice

‚D¿÷P

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

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

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

Provalo online!

In alternativa (merito all'approccio di @ Adnan per il secondo),

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

J, 15 byte (soluzione di @ miglia)

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

Spiegazione

Questa è solo una semplice implementazione dell'algoritmo fornito dall'OP.

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

Spiegazione, la soluzione di @ miglia

Molto intelligente.

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

Mathematica, 33 byte

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

Provalo online!

Gelatina , 8 byte

,ṚḌµ:g/P

Provalo online!

JavaScript (ES7), 67 64 byte

Così tanti byte solo per invertire il numero :(

Accetta l'input come stringa.

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

Provalo

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 byte

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

Provalo online!

R , 108 89 byte

-19 byte grazie a plannapus per il suo 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}

Questo tenterà di allocare almeno un vettore di 4*nbyte di dimensioni (e penso che ne possano arrivare fino a 4), quindi questo genererà un errore di memoria per dimensioni sufficientemente grandi n.

Provalo online!

Python 3 , 73 68 byte

-5 byte grazie a Mr. Xcoder.

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

Provalo online!

MATL , 13 12 11 byte

tVPU*1MZdU/

Provalo online!Oppure verifica tutti i casi di test .

Spiegazione

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 byte

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Provalo online!

Nessun GCD incorporato. ; -;

Buccia , 10 byte

S¤§÷o□⌋*i↔

Provalo online!

-1 grazie a H.PWiz .
-1 grazie a Zgarb .

Japt , 13 12 11 byte

sw
*V/yU ²

Provalo

Spiegazione

Input implicito di numero intero U. La riga vuota all'inizio impedisce la sovrascrittura della riga seguenteU

sw

Converti Uin una stringa ( s), inverti ( w), converti in un numero intero e assegna a variabile V.

*V

Moltiplicare Uper V.

/

Dividere.

yU

GCD di Ve U.

²

Squared. Output implicito dell'intero risultante.

Alternativa, 13 byte

Solo perché mi piace essere in grado di usare N.

NpUsw)mxNry)×

Provalo

Pyth , 13 byte

/*QKs_`Q^iKQ2

Provalo qui!

Pyth , 15 byte

Questo utilizza l'approccio di Adnan e accetta l'input come stringa.

KsM_BQ*Fm/diFKK

Provalo qui

x86 Codice macchina, 39 byte

;;; 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 funzione precedente calcola il "numero di fattore non comune" del parametro di input specificato. A seguito della convenzione di chiamata __fastcall basata su registro , il parametro viene passato nel ECXregistro. Il risultato viene restituito nel EAXregistro, come per tutte le convenzioni di chiamata x86.

Provalo online!

Ci è voluto molto tempo per scrivere in una forma così compatta, ma è stato un esercizio divertente. Molte contorsioni per ottenere la migliore pianificazione dei registri possibile, entro i limiti degli DIVoperandi impliciti dell'istruzione x86 e cercando di usare codifiche brevi diMUL e XCHGistruzioni ogni volta che è possibile. Sarei molto curioso di vedere se qualcuno può pensare a un altro modo per accorciarlo ulteriormente. Alla fine il mio cervello era piuttosto impazzito. Grazie a un compilatore la prossima volta che ne vedi uno! (Anche se questo è un codice decisamente migliore di quello che un compilatore genererebbe ... Soprattutto se lo modificassi leggermente senza vincoli di dimensione, rimuovendo cose come XCHG.)

Perl 5 , 72 byte

71 byte di codice + 1 flag ( -p)

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

Provalo online!

Pyke , 8 byte

_]FbP).^B

Provalo qui!

Accetta l'input come stringa.

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

Python 2 , 70 byte

Grazie a cri everytim .

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

Provalo online!

Python 2 , 77 byte

Nota che in Python 2 non puoi utilizzare il math.gcd()metodo e devi farlo "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

Provalo online!

Ohm , 9 byte

DR«D]Æ┴/µ

Provalo online!

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

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

Provalo online!