Bir sohbet mesajına dayanarak

Meydan okuma

Bir giriş numarası verildiğinde n > 9, baştaki sıfırları yok sayarak tersini oluşturun. Ardından, sayı ve tersinin ortak olmadığı tüm ana faktörlerin bir listesini oluşturun . Girdinin Yaygın Olmayan Faktör Numarasını oluşturmak için bu faktörleri çarpın .

Eğer: Veya başka bir şekilde koymak rev(n)O anlamına gelir tamsayının ondalık ters n, çarpımını hesaplamak nve rev(n)karesine bölünmesiyle gcd(n, rev(n)).

Bu sayıyı çıktılayın.

Çalışılan örnekler

Örneğin, 2244tersine döner 4422. Birincisinin asal faktörleri [2, 2, 3, 11, 17]ve tersinin asal faktörleri [2, 3, 11, 67]. Ortak değil çokluklar rakamlarla [2, 17, 67]yüzden 2278çıkıştır.

Başka bir örnek olarak, 1234tersine döner 4321. Ürün 5332114ve GCD öyle 1, yani çıktı 5332114.

Diğer açıklamalar

Açıkçası bir palindromik sayı, tüm faktörleri tersi ile ortak olacaktır, bu nedenle böyle bir durumda çıktı 1( n*n/n^2) olur. Açıktır ki, 1234örneğin örnekte olduğu gibi, çıktının tüm faktörlerin çarpımı olması da mümkündür (yani gcd 1'dir - girdi ve tersi ortaktır) .

kurallar

• Giriş ve çıktının, dilinizin yerel tamsayı türüne uygun olduğu varsayılabilir.
• Giriş ve çıkış herhangi bir uygun formatta verilebilir .
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine döndürebilirsiniz.
• Mümkünse, diğer kişilerin kodunuzu deneyebilmesi için lütfen bir çevrimiçi test ortamına bağlantı ekleyin!
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 bayt

kod

‚D¿÷P

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Alternatif olarak (@ Adnan'ın ikincisine yaklaşımına bağlı olarak),

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

J, 15 bayt (@ miles's solution)

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

açıklama

Bu OP tarafından verilen algoritmanın basit bir uygulamasıdır.

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

Açıklama, @ miles's solution

Çok zeki.

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

Mathematica, 33 bayt

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

Çevrimiçi deneyin!

Jöle , 8 bayt

,ṚḌµ:g/P

Çevrimiçi deneyin!

JavaScript (ES7), 67 64 bayt

Sadece sayıyı tersine çevirmek için çok bayt :(

Girişi dize olarak alır.

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

Dene

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 bayt

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

Çevrimiçi deneyin!

R , 108 89 bayt

Gcd algoritması için plannapus sayesinde -19 bayt

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}

Bu, en az bir boyut 4*nbayt vektörünü tahsis etmeye çalışacaktır (ve bence 4'e kadar), bu da yeterince büyük bir hafıza hatası atacaktır n.

Çevrimiçi deneyin!

Python 3 , 73 68 bayt

Bay Xcoder sayesinde -5 bayt.

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

Çevrimiçi deneyin!

MATL , 13 12 11 bayt

tVPU*1MZdU/

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

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 bayt

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Çevrimiçi deneyin!

Dahili GCD yok. , -;

Kabuk , 10 bayt

S¤§÷o□⌋*i↔

Çevrimiçi deneyin!

H.PWiz sayesinde -1 .
-1 Zgarb sayesinde .

Japt , 13 12 11 bayt

sw
*V/yU ²

Dene

açıklama

Örtük tamsayı girişi U. Başlangıçtaki boş satır, aşağıdaki satırın üzerine yazılmasını engellerU

sw

UBir dizeye ( s) dönüştürün , ters çevirin ( w), tamsayıya dönüştürün ve değişkene atayın V.

*V

Çarp Utarafından V.

/

Böl.

yU

GCD Vve U.

²

Squared. Sonuçtaki tamsayının örtük çıktısı.

Alternatif, 13 bayt

Sadece kullanabilmeyi sevdiğim için N.

NpUsw)mxNry)×

Dene

Pyth , 13 bayt

/*QKs_`Q^iKQ2

Burada deneyin!

Pyth , 15 bayt

Bu Adnan'ın yaklaşımını kullanır ve girdiyi String olarak alır.

KsM_BQ*Fm/diFKK

Burada deneyin

x86 Makine Kodu, 39 bayt

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

Yukarıdaki fonksiyon, belirtilen giriş parametresinin "nadir faktör numarasını" hesaplar. Kayıt tabanlı __fastcall çağrı kuralından sonra parametre ECXkayıt defterine geçirilir . Sonuç, EAXtüm x86 çağrı kurallarında olduğu gibi kayıt defterinde döndürülür .

Çevrimiçi deneyin!

Bu kadar kompakt bir biçimde yazmak çok uzun sürdü, ama eğlenceli bir egzersizdi. X86 DIVkomutunun örtük işlenenlerinin kısıtlamaları dahilinde mümkün olan en uygun kayıt planlamasını elde etmek için çok sayıda çarpışma MULve veXCHG talimatları . Birinin daha da kısaltmak için başka bir yol düşünüp düşünemeyeceğini görmek çok merak ediyorum. Sonunda beynim oldukça kızardı. Bir dahaki sefere bir derleyici teşekkür ederiz! (Her ne kadar bu yolu gibi şeyler kaldırarak, boyut kısıtlamaları olmaksızın hafifçe tweaked Hele ... Bir derleyici üretecek şeyden daha iyi kod XCHG.)

Perl 5,72 bayt

71 bayt kod + 1 bayrak ( -p)

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

Çevrimiçi deneyin!

Pyke , 8 bayt

_]FbP).^B

Burada deneyin!

Girişi dize olarak alır.

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

Python 2,70 bayt

Sayesinde i cri everytim .

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

Çevrimiçi deneyin!

Python 2 , 77 bayt

Python 2'de math.gcd()yöntemi kullanamayacağınızı ve bunu "elle" yapmanız gerektiğini unutmayın.

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

Çevrimiçi deneyin!

Ohm , 9 bayt

DR«D]Æ┴/µ

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!