Dựa trên tin nhắn trò chuyện

Các thách thức

Cho một số đầu vào n > 9, xây dựng đảo ngược của nó, bỏ qua các số không đầu. Sau đó, xây dựng một danh sách tất cả các thừa số nguyên tố mà số và đảo ngược của nó không có điểm chung. Nhân các yếu tố đó với nhau để tạo Số yếu tố không phổ biến của đầu vào.

Hoặc, nói cách khác: nếu rev(n)biểu thị đảo ngược thập phân của số nguyên n, hãy tính tích của nvà rev(n)chia cho bình phương của gcd(n, rev(n)).

Đầu ra số đó.

Ví dụ làm việc

Ví dụ, 2244đảo ngược đến 4422. Các yếu tố chính của đầu tiên là [2, 2, 3, 11, 17]và các yếu tố chính của đảo ngược là [2, 3, 11, 67]. Các số không trong bội số chung là [2, 17, 67], 2278đầu ra cũng vậy.

Cho một ví dụ khác, 1234đảo ngược đến 4321. Sản phẩm là 5332114và GCD là 1, vì vậy đầu ra là 5332114.

Nhiều sự sáng tỏ hơn

Rõ ràng là một số palindromic sẽ có tất cả các yếu tố chung với mặt trái của nó, vì vậy trong trường hợp như vậy, đầu ra là 1( n*n/n^2). Rõ ràng, đầu ra cũng có thể là phép nhân tất cả các yếu tố (nghĩa là gcd là 1 - đầu vào và đảo ngược của nó là đồng nguyên tố), như trong trường hợp 1234ví dụ.

Quy tắc

• Đầu vào và đầu ra có thể được coi là phù hợp với kiểu số nguyên của ngôn ngữ của bạn.
• Đầu vào và đầu ra có thể được đưa ra trong bất kỳ định dạng thuận tiện .
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E , 6 byte

Mã

‚D¿÷P

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Ngoài ra (tín dụng cho cách tiếp cận của @ Adnan cho cách thứ hai),

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

J, 15 byte (@ giải pháp dặm của)

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

Giải trình

Đây chỉ là một triển khai đơn giản của thuật toán được đưa ra bởi OP.

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

Giải thích, @ giải pháp dặm của

Rất thông minh.

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

Toán học, 33 byte

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

Hãy thử trực tuyến!

Thạch , 8 byte

,ṚḌµ:g/P

Hãy thử trực tuyến!

JavaScript (ES7), 67 64 byte

Vì vậy, nhiều byte chỉ để đảo ngược số :(

Đưa đầu vào dưới dạng một chuỗi.

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

Thử nó

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

Hãy thử trực tuyến!

R , 108 89 byte

-19 byte nhờ vào plannapus cho thuật toán gcd của mình

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}

Điều này sẽ cố gắng phân bổ ít nhất một vectơ 4*nbyte kích thước (và tôi nghĩ có đến 4), vì vậy điều này sẽ gây ra lỗi bộ nhớ cho đủ lớn n.

Hãy thử trực tuyến!

Python 3 , 73 68 byte

-5 byte nhờ ông Xcoder.

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

Hãy thử trực tuyến!

MATL , 13 12 11 byte

tVPU*1MZdU/

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

Hãy thử trực tuyến!

Không có GCD tích hợp. ; -;

Husk , 10 byte

S¤§÷o□⌋*i↔

Hãy thử trực tuyến!

-1 cảm ơn H.PWiz .
-1 cảm ơn Zgarb .

Japt , 13 12 11 byte

sw
*V/yU ²

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U. Dòng trống ở đầu, ngăn dòng sau ghi đèU

sw

Chuyển đổi Uthành một chuỗi ( s), đảo ngược nó ( w), chuyển đổi trở lại một số nguyên và gán cho biến V.

*V

Nhân Uvới V.

/

Chia.

yU

GCD của Vvà U.

²

Bình phương. Ngõ ra đầu ra của số nguyên kết quả.

Thay thế, 13 byte

Chỉ vì tôi thích có thể sử dụng N.

NpUsw)mxNry)×

Thử nó

Bình thường , 13 byte

/*QKs_`Q^iKQ2

Hãy thử nó ở đây!

Bình thường , 15 byte

Điều này sử dụng cách tiếp cận của Adnan và lấy đầu vào dưới dạng Chuỗi.

KsM_BQ*Fm/diFKK

Hãy thử nó ở đây

Mã máy 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

Hàm trên tính toán "số yếu tố không phổ biến" của tham số đầu vào được chỉ định. Theo quy ước gọi __fastcall dựa trên thanh ghi , tham số được truyền vào thanh ECXghi. Kết quả được trả về trong EAXsổ đăng ký, như với tất cả các quy ước gọi x86.

Hãy thử trực tuyến!

Điều này đã mất một thời gian rất dài để viết ở dạng nhỏ gọn như vậy, nhưng nó là một bài tập thú vị. Rất nhiều mâu thuẫn để có được lịch trình đăng ký tối ưu nhất có thể, trong các ràng buộc của DIVtoán hạng ngầm của lệnh x86 và cố gắng sử dụng các mã hóa MULvà XCHGhướng dẫn ngắn bất cứ khi nào có thể. Tôi rất tò mò muốn xem liệu ai đó có thể nghĩ ra một cách khác để rút ngắn nó hơn nữa không. Bộ não của tôi đã khá rán vào cuối. Cảm ơn một trình biên dịch lần sau khi bạn nhìn thấy một! (Mặc dù đây là cách mã tốt hơn so với những gì trình biên dịch sẽ tạo ra ... Đặc biệt là nếu bạn tinh chỉnh nó một chút mà không bị hạn chế kích thước, loại bỏ những thứ như XCHG.)

Perl 5 , 72 byte

71 byte mã + 1 cờ ( -p)

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

Hãy thử trực tuyến!

Pyke , 8 byte

_]FbP).^B

Hãy thử nó ở đây!

Đưa đầu vào dưới dạng một chuỗi.

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

Python 2 , 70 byte

Cảm ơn tôi cri everytim .

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

Hãy thử trực tuyến!

Python 2 , 77 byte

Lưu ý rằng trong Python 2, bạn không thể sử dụng math.gcd()phương thức này và bạn phải thực hiện "bằng tay".

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

Hãy thử trực tuyến!

Ohm, 9 bytes

DR«D]Æ┴/µ

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

Hãy thử trực tuyến!