Berdasarkan pesan obrolan

Tantangan

Diberikan nomor input n > 9, buat kebalikannya, abaikan angka nol di depan. Kemudian, membangun daftar semua faktor utama yang jumlah dan yang terbalik tidak memiliki kesamaan. Lipat gandakan faktor-faktor tersebut bersama-sama untuk membuat Angka Faktor Tidak Biasa dari input.

Atau, dengan kata lain: jika rev(n)menunjukkan pembalikan desimal bilangan bulat n, hitung produk ndan rev(n)dibagi dengan kuadrat gcd(n, rev(n)).

Keluarkan nomor itu.

Contoh yang berhasil

Misalnya, kembali 2244ke 4422. Faktor utama yang pertama adalah [2, 2, 3, 11, 17]dan faktor utama kebalikannya [2, 3, 11, 67]. Angka-angka yang tidak dalam multiplisitas umum adalah [2, 17, 67], demikian 2278juga output.

Untuk contoh lain, 1234balik ke 4321. Produk ini 5332114dan GCD adalah 1, sehingga output 5332114.

Klarifikasi lebih lanjut

Jelas bilangan palindromik akan memiliki semua faktor yang sama dengan kebalikannya, sehingga dalam kasus seperti itu outputnya adalah 1( n*n/n^2). Jelas, itu juga mungkin untuk output menjadi perkalian semua faktor (yaitu, gcd adalah 1 - input dan kebalikannya adalah co-prime), seperti dalam kasus 1234contoh.

Aturan

• Input dan output dapat dianggap sesuai dengan tipe integer asli bahasa Anda.
• Input dan output dapat diberikan dalam format apa pun yang nyaman .
• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Jika memungkinkan, harap sertakan tautan ke lingkungan pengujian online agar orang lain dapat mencoba kode Anda!
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

Contohnya

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 byte

Kode

‚D¿÷P

Menggunakan penyandian 05AB1E . Cobalah online!

Penjelasan

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

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

Cobalah online!

Atau (kredit ke pendekatan @ Adnan untuk yang kedua),

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

J, 15 byte (solusi @ miles)

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

Penjelasan

Ini hanyalah implementasi langsung dari algoritma yang diberikan oleh OP.

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

Penjelasan, solusi @ miles

Sangat pintar.

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

Cobalah online!

Jelly , 8 byte

,ṚḌµ:g/P

Cobalah online!

JavaScript (ES7), 67 64 byte

Begitu banyak byte hanya untuk membalikkan nomor :(

Mengambil input sebagai string.

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

Cobalah

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

Cobalah online!

R, 108 89 bytes

-19 bytes thanks to plannapus for his gcd algorithm

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}

This will attempt to allocate at least one vector of size 4*n bytes (and I think as many as 4), so this will throw a memory error for sufficiently large n.

Try it online!

Python 3, 73 68 bytes

-5 bytes thanks to Mr. Xcoder.

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

Try it online!

MATL, 13 12 11 bytes

tVPU*1MZdU/

Try it online! Or verify all test cases.

Explanation

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

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Try it online!

No GCD built-in. ;-;

Husk, 10 bytes

S¤§÷o□⌋*i↔

Try it online!

-1 terima kasih kepada H.PWiz .
-1 berkat Zgarb .

Japt , 13 12 11 byte

sw
*V/yU ²

Cobalah

Penjelasan

Input bilangan bulat implisit U. Baris kosong di awal, mencegah baris berikut dari menimpaU

sw

Konversi Uke string ( s), balikkan ( w), konversikan kembali ke integer dan tetapkan ke variabel V.

*V

Kalikan Udengan V.

/

Membagi.

yU

GCD dari Vdan U.

²

Kuadrat. Output implisit bilangan bulat yang dihasilkan.

Alternatif, 13 byte

Hanya karena saya suka bisa menggunakan N.

NpUsw)mxNry)×

Cobalah

Pyth, 13 bytes

/*QKs_`Q^iKQ2

Try it here!

Pyth, 15 bytes

This uses Adnan's approach and takes input as a String.

KsM_BQ*Fm/diFKK

Try it here

Kode Mesin x86, 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

Fungsi di atas menghitung "nomor faktor tidak biasa" dari parameter input yang ditentukan. Mengikuti konvensi panggilan panggil __fastcall berbasis , parameter dilewatkan dalam ECXregister. Hasilnya dikembalikan dalam EAXregister, seperti semua konvensi pemanggilan x86.

Cobalah online!

Ini membutuhkan waktu yang sangat lama untuk menulis dalam bentuk yang begitu kompak, tetapi itu adalah latihan yang menyenangkan. Banyak contortions untuk mendapatkan penjadwalan register seoptimal mungkin, dalam batasan DIVoperan implisit instruksi x86 dan mencoba menggunakan penyandian singkat MULdan XCHGinstruksi kapan pun memungkinkan. Saya akan sangat ingin tahu apakah seseorang dapat memikirkan cara lain untuk mempersingkat lebih lanjut. Otak saya cukup digoreng pada akhirnya. Berterimakasihlah kepada seorang kompiler saat Anda melihatnya nanti! (Meskipun ini adalah kode yang jauh lebih baik daripada yang dihasilkan oleh kompiler ... Terutama jika Anda mengubah sedikit tanpa batasan ukuran, menghapus hal-hal seperti XCHG.)

Perl 5 , 72 byte

71 byte kode + 1 bendera ( -p)

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

Cobalah online!

Pyke , 8 byte

_]FbP).^B

Coba di sini!

Mengambil input sebagai string.

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

Python 2 , 70 byte

Terima kasih kepada saya cri everytim .

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

Cobalah online!

Python 2 , 77 byte

Perhatikan bahwa dalam Python 2, Anda tidak dapat menggunakan math.gcd()metode ini, dan Anda harus melakukannya "dengan tangan".

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

Cobalah online!

Ohm , 9 byte

DR«D]Æ┴/µ

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

Cobalah online!