Die ungewöhnliche Faktornummer

15

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
code-golf  arithmetic  number-theory 
— AdmBorkBork
quelle
Können wir annehmen, dass die Eingabe keine führenden Nullen hat?
— Mr. Xcoder
1
@ Mr.Xcoder Huh? Du meinst nachgestellte Nullen?
— Erik der Outgolfer
@EriktheOutgolfer Nein, führende Nullen sind genau das, was ich meine. Also
— Mr. Xcoder
3
Der zweite Testfall sollte sein 1995(glaube ich)
— Mr. Xcoder
1
@ LuisMendo Danke. Gute Ergänzung.
— AdmBorkBork

Antworten:

6

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
— Adnan
quelle
Eine schöne, einfache Alternative zu der Formel in der Herausforderung - +1. Versuchte das gleiche in Japt, aber es kam 2 Bytes länger als das, was ich bereits hatte.
— Shaggy
5

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
— cole
quelle
2
15 Bytes mit*/@(,%+.)|.&.":
— Meilen
@ Meilen Ich liebe die unter Trick
— Cole
@ Meilen, die man wirklich glatt ist.
— Jonah
Warum nicht die 15-Byte-Version als Hauptlösung einsenden?
— Shaggy
@ Shaggy Ich bin mir nicht sicher. Meine Neigung war es, mit "Es ist deutlich anders als ich" zu antworten, aber es sind wirklich nur zwei Optimierungen. Ich werde es später aktualisieren.
— Cole
2

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>
Erweitern Sie das Snippet

— Zottelig
quelle
2

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!

— Giuseppe
quelle
1

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
— Luis Mendo
quelle
1

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

— Zottelig
quelle
Schlauer Trick mit GCD. Ich denke, dass der Algorithmus tatsächlich kürzer sein könnte als die aktuelle Jelly-Lösung ...
— ETHproductions
@ETHproductions In Jelly GCD endet länger ...
— Erik the Outgolfer
@EriktheOutgolfer Ich "habe" eine 8-Byte-Version, aber dies beinhaltet das Teilen der Ergebnisse von zwei Dyaden und ich bin nicht sicher, wie ich das richtig machen soll ...
— ETHproductions
1

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

— Cody Gray
quelle
0

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(^)
— Blau
quelle
0

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!

— Mr. Xcoder
quelle
Python 3 hat gcdals fractions.gcd.
— Totalhuman
@icrieverytim Deshalb habe ich es in Python 2
— gelöst
... Hoppla, ich meinte Python 2. Python 3 hat math.gcd.
— Totalhuman
@icrieverytim erledigt.
— Mr. 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;}

Probieren Sie es online!

— Roberto Graham
quelle
1
In der while-Schleife können Sie ersetzen t!=0 durch t>0, da t nie negativ sein wird. f*r/(i*i)ist das gleiche wie f/i*r/i. Sie können fallen f=t;und r=i;wenn Sie die Zuordnung von iund verketten t.
— Luke
1
Die while-Schleife kann als while(t>0)t=i%(i=t);(-11 Byte) geschrieben werden.
— Nevay
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.