एक चैट संदेश के आधार पर

चुनौती

एक इनपुट नंबर को देखते हुए 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। उत्पाद है 5332114और GCD है 1, इसलिए आउटपुट है 5332114।

और स्पष्टीकरण

जाहिर है कि एक पलिंडोमिक संख्या में इसके रिवर्स के साथ सभी समान कारक होंगे, इसलिए ऐसी स्थिति में आउटपुट 1( n*n/n^2) है। जाहिर है, 1234उदाहरण के मामले में आउटपुट के लिए गुणन सभी कारकों (यानी, जीसीडी 1 - इनपुट और इसके रिवर्स सह-प्राइम हैं) होना भी संभव है ।

नियम

इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट होने के लिए माना जा सकता है।
इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

code-golf arithmetic number-theory

— AdmBorkBork
स्रोत

क्या हम मान सकते हैं कि इनपुट में अग्रणी शून्य नहीं होगा?

— बजे मिस्टर एक्सकोडर

1

@ Mr.Xcoder हुह? आप शून्य का मतलब है?

— आउटगॉल्फ

@ EriktheOutgolfer नहीं, अग्रणी शून्य वास्तव में मेरा मतलब है। इसके अलावा

— मिस्टर एक्सकोडर

3

दूसरा परीक्षण मामला होना चाहिए 1995(मेरा मानना है)

— श्री एक्सकोडर 14

1

@LuisMendo धन्यवाद। अच्छा जोड़।

— AdmBorkBork

6

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

— अदनान
स्रोत

चुनौती में दिए गए सूत्र का एक अच्छा, सरल विकल्प - +1। जाप में भी ऐसा ही किया गया, लेकिन मेरे पास जो पहले से था, उससे 2 बाइट ज्यादा लंबी थी।

— झबरा

5

जे, 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वैकल्पिक रूप से (दूसरे के लिए @ अदनान के दृष्टिकोण का श्रेय),

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

जे, 15 बाइट्स (@ मील का समाधान)

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

व्याख्या

यह ओपी द्वारा दिए गए एल्गोरिदम का सिर्फ एक सीधा कार्यान्वयन है।

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

स्पष्टीकरण, @ मील का समाधान

बहुत चालाक।

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

— गोभी
स्रोत

2

15 बाइट्स के साथ*/@(,%+.)|.&.":

— मील

@ मीलों मैं अंडर ट्रिक से प्यार करता हूं

— कोल

@ मीलों कि एक सच में चालाक है।

— जोना

अपने मुख्य समाधान के रूप में 15 बाइट संस्करण क्यों नहीं प्रस्तुत करें?

— झबरा

@ शागिर्दी को यकीन नहीं हुआ। मेरा झुकाव "यह अपने आप से काफी अलग है" के साथ प्रतिक्रिया करने के लिए था, लेकिन यह वास्तव में सिर्फ दो अनुकूलन है। मैं इसे बाद में अद्यतन करने के लिए मिल जाएगा।

— कोल

4

गणितज्ञ, 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— J42161217
स्रोत

3

जेली , 8 बाइट्स

,ṚḌµ:g/P

इसे ऑनलाइन आज़माएं!

— आउटगोल्फ को एरिक करें
स्रोत

Dammit, मैं बिल्कुल वैसा ही (सिवाय था DUबजाय Ṛ)

— ETHproductions

@ETHproductions हाँ Ṛएक पूर्णांक पर अंकों को उलट देता है लेकिन वापस पूर्णांक में परिवर्तित नहीं होता है।

— आउटगॉल्फ

2

जावास्क्रिप्ट (ईएस 7), 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>

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

हास्केल, 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— nimi
स्रोत

2

आर , 108 89 बाइट्स

-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बाइट्स के कम से कम एक वेक्टर को आवंटित करने का प्रयास करेगा (और मुझे लगता है कि 4 के रूप में कई), इसलिए यह पर्याप्त रूप से बड़े के लिए मेमोरी त्रुटि फेंक देगा n।

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

1

पायथन 3 , 73 68 बाइट्स

-5 बाइट्स मिस्टर एक्सकोडर की बदौलत।

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

68 बाइट्स

— श्री एक्सकोडर 15

1

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

— लुइस मेंडो
स्रोत

1

नीम , 11 बाइट्स

𝕓𝕋₁𝐫𝐕₁𝐕𝕌𝐠ᛦ𝕍

इसे ऑनलाइन आज़माएं!

कोई जीसीडी बिल्ट-इन नहीं। ; -;

— totallyhuman
स्रोत

1

भूसी , 10 बाइट्स

S¤§÷o□⌋*i↔

इसे ऑनलाइन आज़माएं!

-1 H.PWiz को धन्यवाद ।
-1 ज़गारब को धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत

1

जाप , १३ १२ ११ बाइट्स


sw
*V/yU ²

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U। शुरुआत में खाली लाइन, ओवरराइटिंग से निम्न पंक्ति को रोकता हैU

sw

Uएक स्ट्रिंग में परिवर्तित करें ( s), इसे रिवर्स करें ( w), एक पूर्णांक में वापस कनवर्ट करें और चर पर असाइन करें V।

*V

गुणा Uद्वारा V।

फूट डालो।

yU

की GCD Vऔर U।

²

चुकता। परिणामी पूर्णांक का निहित उत्पादन।

वैकल्पिक, 13 बाइट्स

सिर्फ इसलिए कि मुझे इस्तेमाल करना पसंद है N।

NpUsw)mxNry)×

कोशिश करो

— झबरा
स्रोत

जीसीडी के साथ स्मार्ट ट्रिक। मुझे लगता है कि एल्गोरिथ्म वास्तव में वर्तमान जेली समाधान से कम हो सकता है ...

— ETHproductions

जेली जीसीडी में @ETHproductions लंबे समय तक समाप्त होता है ...

— 15

@EriktheOutgolfer I में "8-बाइट संस्करण" है, लेकिन इसमें दो रंजक के परिणामों को विभाजित करना शामिल है और मुझे यकीन नहीं है कि कैसे ठीक से किया जाए ...

— ETHproductions

1

पायथ , 13 बाइट्स

/*QKs_`Q^iKQ2

यहाँ यह कोशिश करो!

Pyth , 15 बाइट्स

यह अदनान के दृष्टिकोण का उपयोग करता है और एक स्ट्रिंग के रूप में इनपुट लेता है।

KsM_BQ*Fm/diFKK

इसे यहाँ आज़माएँ

— मिस्टर एक्सकोडर
स्रोत

1

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।)

— कोडी ग्रे
स्रोत

0

पर्ल 5 , 72 बाइट्स

कोड + 1 ध्वज के 71 बाइट्स ( -p)

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

Pyke , 8 बाइट्स

_]FbP).^B

यहाँ यह कोशिश करो!

एक स्ट्रिंग के रूप में इनपुट लेता है।

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

— नीला
स्रोत

0

पायथन 2 , 70 बाइट्स

के लिए धन्यवाद मैं CRI everytim ।

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

इसे ऑनलाइन आज़माएं!

पायथन 2 , 77 बाइट्स

ध्यान दें कि पायथन 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

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत

अजगर 3 के gcdरूप में है fractions.gcd।

— पूरी तरह से

@icrieverytim यही कारण है कि मैंने इसे पायथन 2 में हल करने के लिए चुना।

— श्री एक्सकोडर

... वूप्स, मेरा मतलब था पायथन 2. पायथन 3 है math.gcd।

— पूरी तरह से

@icrieverytim किया।

— श्री एक्सकोडर

0

ओम , 9 बाइट्स

DR«D]Æ┴/µ

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

psst ... ओम v2 बाहर और पहले से कहीं ज्यादा बेहतर है!

— निक क्लिफर्ड

0

जावा 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;}

इसे ऑनलाइन आज़माएं!

— रॉबर्टो ग्राहम
स्रोत

1

जबकि लूप में, आप t!=0द्वारा प्रतिस्थापित कर सकते हैं t>0, क्योंकि t कभी भी नकारात्मक नहीं होगा। f*r/(i*i)के रूप में ही है f/i*r/i। आप ड्रॉप कर सकते हैं f=t;और r=i;अगर आप का काम श्रृंखला iऔर t।

— ल्यूक

1

जबकि लूप को while(t>0)t=i%(i=t);(-11 बाइट्स) के रूप में लिखा जा सकता है ।

— नेवई