ขึ้นอยู่กับข้อความแชท

ความท้าทาย

กำหนดหมายเลขอินพุตn > 9สร้าง reverse โดยไม่คำนึงถึงศูนย์นำหน้า จากนั้นสร้างรายการปัจจัยหลักทั้งหมดที่จำนวนและการย้อนกลับไม่เหมือนกัน คูณปัจจัยเหล่านั้นเข้าด้วยกันเพื่อสร้างจำนวนปัจจัยที่ไม่ธรรมดาของอินพุต

หรือจะนำมันวิธีอื่น: ถ้าrev(n)หมายถึงการกลับรายการทศนิยมของจำนวนเต็มnคำนวณผลิตภัณฑ์ของnและหารด้วยตารางของrev(n)gcd(n, rev(n))

เอาท์พุทจำนวนนั้น

ตัวอย่างการทำงาน

ยกตัวอย่างเช่นกลับไป2244 4422ปัจจัยสำคัญของการเป็นครั้งแรกและเป็นปัจจัยสำคัญของการกลับเป็น[2, 2, 3, 11, 17] [2, 3, 11, 67]ตัวเลขไม่ได้อยู่ใน multiplicities ทั่วไป[2, 17, 67]เพื่อให้2278เป็นเอาท์พุท

สำหรับตัวอย่างอื่นให้1234กลับไป4321เป็น ผลิตภัณฑ์ที่เป็น5332114และ GCD คือเพื่อให้ออกเป็น15332114

ชี้แจงเพิ่มเติม

เห็นได้ชัดว่าจำนวน palindromic จะมีปัจจัยทั้งหมดเหมือนกันกับการย้อนกลับดังนั้นในกรณีนี้การส่งออกเป็น1( n*n/n^2) เห็นได้ชัดว่ามันเป็นไปได้ที่เอาท์พุทจะเป็นการคูณปัจจัยทั้งหมด (เช่น gcd คือ 1 - อินพุทและรีเวิร์สกลับเป็น co-prime) เช่นในกรณีของ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 ไบต์

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

ลองออนไลน์!

อีกทางหนึ่ง (ให้เครดิตตามแนวทางของ @ 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 ไบต์

-19 ไบต์ขอบคุณ plannapus สำหรับอัลกอริทึม gcd ของเขา

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ไบต์ (และฉันคิดว่ามากที่สุดเท่าที่ 4) nดังนั้นนี้จะโยนความผิดพลาดของหน่วยความจำขนาดใหญ่พอสมควร

ลองออนไลน์!

Python 3 , 73 68 ไบต์

-5 ไบต์ขอบคุณ Mr. Xcoder

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

Neim , 11 ไบต์

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

ลองออนไลน์!

ไม่มี GCD ในตัว ; -;

Huskขนาด 10 ไบต์

S¤§÷o□⌋*i↔

ลองออนไลน์!

-1 ขอบคุณที่H.PWiz
-1 ขอบคุณที่Zgarb

Japt , 13 12 11 ไบต์

sw
*V/yU ²

ลองมัน

คำอธิบาย

Uการป้อนข้อมูลโดยนัยของจำนวนเต็ม บรรทัดว่างที่จุดเริ่มต้นป้องกันไม่ให้บรรทัดต่อไปนี้เขียนทับU

sw

แปลงUเป็นสตริง ( s) ย้อนกลับ ( w) Vแปลงกลับเป็นจำนวนเต็มและกำหนดให้กับตัวแปร

*V

คูณโดยUV

/

การแบ่ง.

yU

GCD ของและVU

²

Squared เอาท์พุทโดยนัยของจำนวนเต็มผล

ทางเลือก 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 ทั้งหมด

ลองออนไลน์!

ใช้เวลานานมากในการเขียนในรูปแบบที่กะทัดรัด แต่มันก็เป็นการออกกำลังกายที่สนุก มีความขัดแย้งมากมายที่จะทำให้กำหนดการลงทะเบียนดีที่สุดเท่าที่จะเป็นไปได้ภายใต้ข้อ จำกัด ของDIVตัวถูกดำเนินการโดยปริยายของคำสั่งx86 และพยายามใช้การเข้ารหัสสั้น ๆMULและXCHGคำแนะนำทุกครั้งที่ทำได้ ฉันอยากรู้ว่าคนอื่นจะคิดวิธีอื่นให้สั้นลงได้อีกหรือไม่ สมองของฉันค่อนข้างทอดในตอนท้าย ขอขอบคุณนักแปลในครั้งต่อไปที่คุณเห็น! (แม้ว่านี่จะเป็นวิธีที่ดีกว่าโค้ดที่คอมไพเลอร์จะสร้าง ... โดยเฉพาะถ้าคุณบิดมันเล็กน้อยโดยไม่มีข้อ จำกัด ด้านขนาดให้ลบสิ่งที่ชอบXCHGออก)

Perl 5 , 72 ไบต์

รหัส 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]Æ┴/µ

ลองออนไลน์!

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

ลองออนไลน์!