チャットメッセージに基づく

チャレンジ

入力番号を指定するとn > 9、そのゼロを無視してその逆を構築します。次に、その数とその逆数に共通しないすべての素因数のリストを作成します。これらの因子を乗算して、入力の非共通因子数を作成します。

それとも、別の言い方をするには、次の場合はrev(n)、整数の表し、小数の逆転n、の積を計算nしてrev(n)の二乗で割りましたgcd(n, rev(n))。

その番号を出力します。

実施例

たとえば、に2244逆になり4422ます。最初[2, 2, 3, 11, 17]の素因数はであり、逆の素因数は[2, 3, 11, 67]です。共通の多重度にない数値はであり、出力も[2, 17, 67]同様2278です。

別の例では、と1234逆になり4321ます。製品は5332114GCDで1あるため、出力は5332114です。

さらなる説明

明らかに、回文数はその逆とすべての因子を共有するため、このような場合、出力は1（n*n/n^2）です。明らかに、例の場合のように、出力がすべての因子の乗算になることも可能です（つまり、gcdは1-入力とその逆は互いに素です）1234。

ルール

• 入力と出力は、言語のネイティブ整数型に適合すると仮定できます。
• 入力と出力は、任意の便利な形式で指定できます。
• 完全なプログラムまたは機能のいずれかが受け入れられます。関数の場合、出力する代わりに出力を返すことができます。
• 可能であれば、他の人がコードを試すことができるように、オンラインテスト環境へのリンクを含めてください！
• 標準的な抜け穴は禁止されています。
• これはコードゴルフなので、通常のゴルフルールがすべて適用され、最短のコード（バイト単位）が勝ちます。

例

in
out

17
1207

208
41704

315
1995

23876
101222302

05AB1E、6バイト

コード

‚D¿÷P

05AB1Eエンコードを使用します。オンラインでお試しください！

説明

‚        # 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バイト

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

オンラインでお試しください！

別の方法（2番目のアプローチに対する@Adnanのアプローチの功績）

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

J、15バイト（@milesのソリューション）

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

説明

これは、OPによって指定されたアルゴリズムの単純な実装です。

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

説明、@ milesのソリューション

非常に賢い。

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

Mathematica、33バイト

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

オンラインでお試しください！

ゼリー、8バイト

,ṚḌµ:g/P

オンラインでお試しください！

JavaScript（ES7）、67 64バイト

数を逆にするだけの非常に多くのバイト:(

入力を文字列として受け取ります。

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

それを試してみてください

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バイト

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

オンラインでお試しください！

R、108 89バイト

gcdアルゴリズムのplannapusのおかげで-19バイト

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}

これは、サイズ4*nバイトのベクトルを少なくとも1つ割り当てようとします（最大4つと思います）。これにより、十分な大きさのメモリエラーがスローされますn。

オンラインでお試しください！

Pythonの3、73の 68バイト

Xcoder氏のおかげで-5バイト。

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

オンラインでお試しください！

MATL、13 12 11バイト

tVPU*1MZdU/

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

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

ニーム、11バイト

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

オンラインでお試しください！

GCDは組み込まれていません。;-;

殻、10バイト

S¤§÷o□⌋*i↔

オンラインでお試しください！

-1 H.PWizに感謝します。
-1 Zgarbに感謝します。

Japt、13 12 11バイト

sw
*V/yU ²

それを試してみてください

説明

integerの暗黙的な入力U。最初の空行は、次の行が上書きされないようにしますU

sw

U文字列に変換（s）、逆w変換（）、整数に変換し直してvariableに割り当てますV。

*V

で乗算UしVます。

/

分けます。

yU

GCD VとU。

²

二乗。結果の整数の暗黙的な出力。

代替、13バイト

使えるのが好きだからN。

NpUsw)mxNry)×

それを試してみてください

Pyth、13バイト

/*QKs_`Q^iKQ2

ここで試してみてください！

Pyth、15バイト

これはAdnanのアプローチを使用し、入力を文字列として受け取ります。

KsM_BQ*Fm/diFKK

ここで試してみてください

x86マシンコード、39バイト

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

上記の関数は、指定された入力パラメーターの「非共通因子数」を計算します。レジスタベースの__fastcall呼び出し規約に従って、パラメータがECXレジスタに渡されます。EAXすべてのx86呼び出し規約と同様に、結果はレジスタに返されます。

オンラインでお試しください！

これは、このようなコンパクトなフォームで書くのに非常に長い時間がかかりましたが、楽しい練習でした。x86 DIV命令の暗黙のオペランドの制約内で、可能な限り最適なレジスタスケジューリングを実現するための多くのゆがみと、可能な限り短いエンコーディングMULとXCHG命令の使用を試みます。誰かがそれをさらに短縮する別の方法を考えられるかどうかを知りたいと思います。私の脳は最後までかなり揚げていました。次回、コンパイラをご覧ください！（これはあるものの道あなたがのようなものを削除し、サイズの制約なしに、わずかにそれを微調整場合は特に...コンパイラが生成されるものよりもより良いコードXCHG。）

Perl 5バイト

71バイトのコード+ 1フラグ（-p）

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

オンラインでお試しください！

Pyke、8バイト

_]FbP).^B

ここで試してみてください！

入力を文字列として受け取ります。

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

Python 2、70バイト

私criのおかげでeverytim。

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

オンラインでお試しください！

Python 2、77バイト

Python 2ではmath.gcd()メソッドを使用できないため、「手作業」で行う必要があることに注意してください。

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

オンラインでお試しください！

オーム、9バイト

DR«D]Æ┴/µ

オンラインでお試しください！

ジャワ8、158 150 148 138 125の 123 116 107 + 19バイト

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

オンラインでお試しください！