Basierend auf einer Chatnachricht

Die Herausforderung

n > 9Konstruieren Sie bei einer gegebenen Eingabenummer die Umkehrung und ignorieren Sie führende Nullen. Dann konstruiere eine Liste aller Primfaktoren, die die Zahl und ihre Umkehrung nicht gemeinsam haben. Multiplizieren Sie diese Faktoren, um die ungewöhnliche Faktornummer der Eingabe zu erhalten.

Oder anders ausgedrückt: Wenn rev(n)die dezimale Umkehrung der Ganzzahl bezeichnet n, berechnen Sie das Produkt von nund rev(n)dividieren Sie es durch das Quadrat von gcd(n, rev(n)).

Gib diese Nummer aus.

Arbeitsbeispiele

Beispiel: 2244kehrt zu um 4422. Die Primfaktoren der ersten sind [2, 2, 3, 11, 17]und die Primfaktoren der umgekehrten sind [2, 3, 11, 67]. Die Zahlen, die keine gemeinsamen Multiplizitäten sind [2, 17, 67], 2278sind auch die Ausgabe.

In einem anderen Beispiel wird 1234umgekehrt zu 4321. Das Produkt ist 5332114und der GCD ist 1, so ist die Ausgabe 5332114.

Weitere Erläuterungen

Offensichtlich hat eine palindromische Zahl alle ihre Faktoren mit ihrer Umkehrung gemeinsam. In diesem Fall ist die Ausgabe also 1( n*n/n^2). Offensichtlich ist es auch möglich, dass der Ausgang die Multiplikation aller Faktoren ist (dh der gcd ist 1 - der Eingang und seine Umkehrung sind Co-Prime), wie im Fall des 1234Beispiels.

Regeln

• Es kann davon ausgegangen werden, dass die Eingabe und Ausgabe in den systemeigenen Ganzzahltyp Ihrer Sprache passen.
• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 Bytes

Code

‚D¿÷P

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Alternativ (Dank an @ Adnans Ansatz für den zweiten),

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

J, 15 Bytes (@miles Lösung)

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

Erläuterung

Dies ist nur eine einfache Implementierung des vom OP vorgegebenen Algorithmus.

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

Erklärung, @miles Lösung

Sehr schlau.

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

Probieren Sie es online!

Gelee , 8 Bytes

,ṚḌµ:g/P

Probieren Sie es online!

JavaScript (ES7), 67 64 Bytes

So viele Bytes, nur um die Zahl umzukehren :(

Übernimmt die Eingabe als Zeichenfolge.

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

Versuch es

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

Probieren Sie es online!

R , 108 89 Bytes

-19 bytes dank plannapus für seinen gcd algorithmus

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}

Dies wird versuchen, mindestens einen Vektor mit einer Größe von 4*nBytes zuzuweisen (und ich denke, es sind bis zu 4), so dass dies einen Speicherfehler für ausreichend große auslöst n.

Probieren Sie es online!

Python 3 , 73 68 Bytes

-5 Bytes dank Mr. Xcoder.

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

Probieren Sie es online!

MATL , 13 12 11 Bytes

tVPU*1MZdU/

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Probieren Sie es online!

Kein GCD eingebaut. ; -;

Schale , 10 Bytes

S¤§÷o□⌋*i↔

Probieren Sie es online!

-1 danke an H.PWiz .
-1 danke an Zgarb .

Japt , 13 12 11 Bytes

sw
*V/yU ²

Versuch es

Erläuterung

Implizite Eingabe einer Ganzzahl U. Die leere Zeile am Anfang verhindert, dass die folgende Zeile überschrieben wirdU

sw

Konvertieren Sie Uin einen String ( s), kehren Sie ihn um ( w), konvertieren Sie zurück in eine Ganzzahl und weisen Sie der Variablen zu V.

*V

Multiplizieren Udurch V.

/

Teilen.

yU

GCD von Vund U.

²

Kariert. Implizite Ausgabe der resultierenden Ganzzahl.

Alternative, 13 Bytes

Nur weil ich es gerne nutzen kann N.

NpUsw)mxNry)×

Versuch es

Pyth , 13 Bytes

/*QKs_`Q^iKQ2

Probieren Sie es hier aus!

Pyth , 15 Bytes

Hierbei wird der Ansatz von Adnan verwendet und die Eingabe als Zeichenfolge verwendet.

KsM_BQ*Fm/diFKK

Probieren Sie es hier aus

x86-Maschinencode, 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

Die obige Funktion berechnet die "ungewöhnliche Faktornummer" des angegebenen Eingabeparameters. Der Parameter wird gemäß der registrierungsbasierten __fastcall-Aufrufkonvention im ECXRegister übergeben. Das Ergebnis wird in der zurückgegebenEAX wie bei allen x86-Aufrufkonventionen Register zurückgegeben.

Probieren Sie es online!

Es hat unglaublich lange gedauert, bis ich so kompakt geschrieben habe, aber es hat Spaß gemacht. Viele Verzerrungen, um die bestmögliche Registerplanung im Rahmen der DIVimpliziten Operanden des x86- Befehls zu erzielen MULund XCHGmöglichst kurze Codierungen und Befehle zu verwenden. Ich wäre sehr gespannt, ob sich jemand einen anderen Weg ausdenken kann, um ihn weiter zu verkürzen. Mein Gehirn war am Ende ziemlich durchgebraten. Vielen Dank, dass Sie das nächste Mal einen Compiler sehen! (Obwohl dies ein viel besserer Code ist als der, den ein Compiler generieren würde ... Insbesondere, wenn Sie ihn ohne Größenbeschränkungen leicht angepasst und Dinge wie entfernt haben XCHG.)

Perl 5 , 72 Bytes

71 Byte Code + 1 Flag ( -p)

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

Probieren Sie es online!

Pyke , 8 Bytes

_]FbP).^B

Probieren Sie es hier aus!

Übernimmt die Eingabe als Zeichenfolge.

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

Python 2 , 70 Bytes

Danke an i cri everytim .

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

Probieren Sie es online!

Python 2 , 77 Bytes

Beachten Sie, dass Sie in Python 2 die math.gcd()Methode nicht verwenden können und sie "von Hand" ausführen müssen.

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

Probieren Sie es online!

Ohm , 9 Bytes

DR«D]Æ┴/µ

Probieren Sie es 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;}

Probieren Sie es online!