अपने पड़ोसियों के साथ प्रमुख प्रवासियों को स्वैप करें

Question

( अपने पड़ोसियों के साथ बिट्स स्वैपिंग के बारे में मेरे सवाल का अनुगमन करें ।)

कार्य

एक सकारात्मक पूर्णांक x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) · ... को देखते हुए , प्रत्येक पूर्णांक युग्मों के लिए इस गुणनखंड में घातांक को स्वैप करके प्राप्त पूर्णांक को प्रिंट करें, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

OEIS में A061898 । यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है!

परीक्षण के मामलों

1 -> 1
2 -> 3
3 -> 2
10 -> 21
37 -> 31
360 -> 756
12345 -> 11578
67895678 -> 125630871

Comments

क्या हम 1 के बजाय ट्रू लौटा सकते हैं ?

— डेनिस

@ डेनिस कुछ विचार के बाद, मैंने फैसला किया है कि मेरा जवाब नहीं है। आउटपुट कम से कम एक संख्या की तरह दिखना चाहिए ।

— लिन

Answer 1

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

ÆE;0s2UFÆẸ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ÆE;0s2UFÆẸ  Main link. Argument: n

ÆE          Yield the exponents of n's prime factorization.
  ;0        Append a zero.
    s2      Split into pairs.
      U     Upend; reverse each pair.
       F    Flatten the resulting list of pairs.
        ÆẸ  Convert the prime exponents to integer.

Answer 2

जेली, 17 16 11 बाइट्स

5 बाइट्स डेनिस के लिए धन्यवाद।

ÆfÆC’^1‘ÆNP

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

व्याख्या

ÆfÆC’^1‘ÆNP   Main monadic chain. Argument: n

Æf            Yield the prime factors of n.
  ÆC          For each factor, count the number of primes below it.
              This effectively yields their indices.
    ’         Decrement [each] by 1.
     ^1       Xor with 1
       ‘      Increment [each] by 1.
        ÆN    Find their corresponding primes.
          P   Yield their product.

पिछला 16-बाइट संस्करण

ÆnÆRiЀÆf’^1‘ÆNP

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

व्याख्या

ÆnÆRiЀÆf’^1‘ÆNP   Main monadic chain. Argument: n

Æn                 Yield the next prime from n.
  ÆR               Yield all primes from 2 to it.
       Æf          Yield prime factors of n
    iЀ            Yield their index in the prime list.
         ’         Decrement [each] by 1.
          ^1       Xor with 1
            ‘      Increment [each] by 1.
             ÆN    Find their corresponding primes.
               P   Yield their product.

पिछला 17-बाइट संस्करण:

ÆnÆR©iЀÆf’^1‘ị®P

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

व्याख्या

ÆnÆR©iЀÆf’^1‘ị®P   Main monadic chain. Argument: n

Æn                  Yield the next prime from n.
  ÆR                Yield all primes from 2 to it.
    ©               Store to register.
        Æf          Yield prime factors of n
     iЀ            Yield their index in the prime list.
          ’         Decrement [each] by 1.
           ^1       Xor with 1
             ‘      Increment [each] by 1.
              ị®    Find their corresponding primes in
                    the list in register.
                P   Yield their product.

Answer 3

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

1##&@@(Prime[BitXor[PrimePi@#+1,1]-1]^#2&)@@@FactorInteger@#/._@_->1&

एक अनाम फ़ंक्शन जो पूर्णांक लेता है और लौटाता है। यह इनपुट पर एक त्रुटि फेंकता है 1लेकिन फिर भी सही परिणाम की गणना करता है।

व्याख्या

हमेशा की तरह, सभी वाक्यात्मक चीनी के कारण, पढ़ने का क्रम थोड़ा अजीब है। एक &सही परिभाषित करता है एक अनाम समारोह और अपने तर्कों पर से जाने जाते हैं #, #2, #3, आदि

...FactorInteger@#...

हम इनपुट फैक्टरिंग द्वारा शुरू करते हैं। यह जोड़े की सूची देता है {prime, exponent}जैसे इनपुट 12देता है {{2, 2}, {3, 1}}। थोड़ा असुविधाजनक, 1देता है {{1, 1}}।

(...&)@@@...

यह स्तर 1 पर पूर्णांकों की सूची में बाईं ओर फ़ंक्शन को लागू करता है, यह फ़ंक्शन प्रत्येक जोड़ी के लिए कहा जाता है, प्राइम और घातांक को अलग-अलग तर्कों के रूप में पारित करता है, और फिर परिणामों की एक सूची देता है। (यह सूची पर फ़ंक्शन को मैप करने के समान है, लेकिन एक जोड़ी प्राप्त करने की तुलना में दो अलग-अलग तर्क प्राप्त करना अधिक सुविधाजनक है।)

...PrimePi@#...

हम बिल्ट-इन का उपयोग करके (प्राइम) इनपुट तक और (सहित) प्राइम की संख्या की गणना करते हैं PrimePi। यह हमें प्रमुख का सूचकांक देता है।

...BitXor[...+1,1]-1...

परिणाम बढ़ा हुआ है, XOR'ed के साथ 1और फिर से घटाया गया है। यह स्वैप 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., यानी सभी 1-आधारित सूचकांक। ध्यान दें कि इस प्रक्रिया के लिए इनपुट 1मिलेगा 0, PrimePiजिसके बाद मैप किया -1जाएगा। हम बाद में उससे निपटेंगे।

 ...Prime[...]^#2...

अब हम n वें अभाज्य को प्राप्त करते हैं (जहाँ n पिछली संगणना से परिणाम है), जो कि सही ढंग से अदला-बदली का अभाज्य है, और इसे इनपुट के गुणन में मूल अभाज्य की शक्ति तक बढ़ाते हैं। इस बिंदु पर Prime[-1]एक त्रुटि फेंक देंगे, लेकिन खुद को निर्विवाद रूप से वापस कर देंगे। इस मामले में शक्ति 1इतनी है कि पूरी प्रक्रिया अब तक {Prime[-1]}इनपुट के लिए पैदावार 1और अन्य सभी इनपुट के लिए सही प्रधान शक्तियों की एक सूची है।

 1##&@@...

अगला, हम सिर्फ सभी प्रमुख शक्तियों को गुणा करते हैं। समारोह के 1##&लिए एक मानक गोल्फ चाल है Times। देखें इस टिप यह कैसे काम करता लिए (अनुभाग "बहस के दृश्यों")।

अंत में, हमें इनपुट का ध्यान रखना होगा 1जिसके लिए उपरोक्त सभी का परिणाम है Prime[-1]। हम एक सरल प्रतिस्थापन नियम के साथ इसे आसानी से ठीक कर सकते हैं। याद रखें कि इसके f@xलिए कम है f[x]। हम बस उस फॉर्म की किसी भी अभिव्यक्ति से मेल खाना चाहते हैं (क्योंकि अन्य सभी परिणाम पूर्णांक होंगे, अर्थात परमाणु अभिव्यक्ति), और इसे इसके साथ बदलें 1:

.../._@_->1

यहाँ, इसके /.लिए संक्षिप्त है ReplaceAll, _@_फॉर्म की f[x]किसी भी चीज के लिए एक पैटर्न है (अर्थात किसी एकल बच्चे के साथ कोई भी मिश्रित अभिव्यक्ति) और ->1कहता है कि "इसके साथ बदलें 1"।

Answer 4

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

10 बाइट्स डेनिस के लिए धन्यवाद।

n=input()
p=f=1;w=[2]
while w[-1]<=n:f*=p;p+=1;w+=[p]*(-~f%p<1)
r=p=1;w=w[1:]
while n>1:
    p+=1
    while n%p<1:n/=p;r*=w[w.index(p)^1]
print r

Comments

input()अजगर 2 में काम करता है?

— NoOneIsHere

@NoOneIsHere हाँ, यह eval(input())पायथन 3 के बराबर है ।

— मेघो

Answer 5

MATL , 17 बाइट्स

EZqGYfy&mt2\Eq+)p

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

व्याख्या

यह घातांक का सीधे उपयोग नहीं करता है। इसके बजाय, यह अगले या पूर्ववर्ती प्रमुख द्वारा प्रत्येक (संभवतः दोहराया गया) प्रमुख कारक को स्वैप करता है।

EZq    % Implicit input. Multiply by 2
Zq     % Array with sequence of primes up to that (this is more than enough)
GYf    % Prime factors of input, with possible repetitions
y      % Duplicate array with sequence of primes
&m     % Indices of prime factors in the sequence of primes
t2\    % Duplicate, modulo 2. Gives 0 for even indices, 1 for odd
Eq     % Multiply by 2, add 1. Transforms 0 / 1 into -1 / 1 
+      % Add. This modifies the indices to perform the swapping
)      % Apply the new indices into the sequence of primes
p      % Product. Implicit display

Answer 6

जूलिया, 64 बाइट्स

~=primes
!n=prod(t->(~3n)[endof(~t[1])+1$1-1]^t[2],factor(2n))/3

इसे ऑनलाइन आज़माएं! पिछले परीक्षण मामले में TIO के लिए बहुत अधिक मेमोरी की आवश्यकता है, लेकिन मैंने इसे स्थानीय रूप से सत्यापित किया है।

यह काम किस प्रकार करता है

विशेष-आवरण इनपुट से बचने के लिए 1 - एक खाली शब्दकोश के उत्पाद को परिभाषित नहीं किया गया है - हम इनपुट एन को 2 से गुणा करते हैं और अंतिम परिणाम को इसकी जोड़ी 3 से विभाजित करते हैं ।

factor(2n)शब्दकोश के रूप में 2n के प्रमुख कारकों के सभी सकारात्मक घातांक देता है । शब्दकोश में पुनरावृति होने पर, हमें कुंजी-मान / प्राइम-एक्सपोनेंट जोड़े मिलेंगे। फ़ंक्शन prodइन जोड़ों को ले जाएगा, t->...उन्हें अनाम फ़ंक्शन लागू करें और परिणामों के उत्पाद को वापस कर दें।

प्रत्येक जोड़ी के लिए टी = (पी, ई) , endof(~t[1])या endof(primes(t[1]))वापसी कश्मीर , कि कम कर रहे हैं या करने के लिए बराबर का अभाज्य की संख्या पी , कि अर्थ पी है कश्मीर ^वें प्रधानमंत्री।

+1$1-1वेतन वृद्धि k , XOR k + 1 के साथ 1 और परिणाम में कमी करेगा। यदि k विषम है, तो k + 1 सम है, इसलिए XOR वेतन वृद्धि और अंतिम परिणाम k + 1 है । यदि k सम है, k + 1 विषम है, तो XOR घटता है और अंतिम परिणाम k - 1 है ।

अंत में, हम सब रूढ़ अंक की गणना छोटा या बराबर है 3n साथ (~3n)या primes(3n)(के उच्चतम प्रधानमंत्री कारक 2n कम है या के बराबर n अगर n> 2 , और वहाँ हमेशा के बीच एक प्रमुख है n और 2 एन ), पर सूचकांक एक को चुनें k + 1 या के - 1 , और इसे ई ^वें शक्ति के साथ ऊपर उठाएं ^t[2]।

Answer 7

पायथन 2, 112 109 108 95 94 बाइट्स

f=lambda n,k=4,m=6,p=[3,2]:1/n or n%p[1]and f(n,k+1,m*k,m*m%k*[k]+p)or p[len(p)*2%4]*f(n/p[1])

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

जब f कहा जाता है, तो यह पहली बार 1 / n गणना करता है । यदि परिणाम गैर-शून्य है, n है 1 और च रिटर्न 1 ।

यदि n> 1 , तो निम्न होता है।

• यदि n , p [1] (शुरू में 2 ) से विभाज्य नहीं है , n%p[1]तो एक सत्य मान प्राप्त करता है और

  f(n,k+1,m*k,m*m%k*[k]+p)

  कहा जाता है।

  यह शाखा अभाज्य संख्या तब तक उत्पन्न करती है जब तक कि एक समान रूप से विभाजित न हो जाए । ऐसा करने के लिए, यह विल्सन के प्रमेय के निम्नलिखित कोरोलरी का उपयोग करता है ।

  

  सभी समय में, मीटर के भाज्य के बराबर है कश्मीर - 1 (शुरू में 6 = 3! और 4 प्रत्येक यात्रा में, का परिणाम है। m*m%k*[k]अभाज्य संख्या की सूची के लिए prepended हो जाता है पी परिणाम रखकर। m*m%kहै 1 अगर कश्मीर प्रधानमंत्री है और 0 यदि नहीं, तो यह k को p और यदि केवल k एक अभाज्य संख्या है, को प्रस्तुत करता है।

• यदि n p [1] से विभाज्य है , तो n%p[1]पैदावार 0 और है

  p[len(p)*2%4]*f(n/p[1])

  निष्पादित हो जाता है।

  यदि p में अभाज्य संख्याओं की मात्रा समाहित है, len(p)*2%4तो 0 प्राप्त होगा और पहला गुणक p [0] का मान लेता है । यदि p में विषम संख्या में अभाज्य संख्याएँ हैं, len(p)*2%4तो 2 का उत्पादन होगा और पहला गुणक p [2] का मान लेता है ।

  किसी भी स्थिति में, यह वह अभियोक्ता है जिसके प्रतिपादकों को p [1] में से एक की अदला-बदली करनी होती है, इसलिए हम n को p [1] से विभाजित करते हैं (घातांक को 1 से घटाते हैं ) और f(n/p[1])इसी अभाज्य के परिणाम को गुणा करते हैं (बढ़ते हुए) प्रतिपादक 1 )।

  ध्यान दें कि उनके डिफ़ॉल्ट मानों में k , m और p को f(n/p[1])रीसेट करता है । छह अतिरिक्त बाइट्स की कीमत पर दक्षता में सुधार होगा।f(n/p[1],k,m,p)

Answer 8

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

JfP_TSfP_ThQ*F+1m@Jx1xJdP

परीक्षण सूट।

व्याख्या

JfP_TSfP_ThQ*F+1m@Jx1xJdP

           Q    get input
          h     add one
      fP_T      find the first prime after it
     S          range from 1 to that prime
 fP_T           filter for the primes
J               assign to J

                        P  prime factorize input
                m      d   for each factor
                     xJ    find its index in J
                   x1      xor with 1
                 @J        find the corresponding entry in J
            *F+1           product of the whole list

Answer 9

जूलिया, 155 131 127 बाइट्स

n->(x=[sort([merge([p=>0for p=primes(n+1)],factor(n))...]);1=>0];prod([x[i-1][1]^x[i][2]*x[i][1]^x[i-1][2]for i=2:2:endof(x)]))

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें। इसके लिए जूलिया संस्करण <0.5 की आवश्यकता है क्योंकि 0.5 में प्राइम कार्यक्षमता को बेस से हटा दिया गया है।

Ungolfed:

function f(n::Int)
    # Create an array of pairs by merging the Dict created from factoring n
    # with all primes less than n+1 with a 0 exponent. Append an extra pair
    # to account for 1 and situations where x would otherwise have odd length.
    x = [sort([(merge([p=>0 for p in primes(n+1)], factor(n))...]); 1=>0]

    # Compute a^d * c^b, where a and c are primes with b and d as their
    # respective exponents.
    prod([x[i-1][1]^x[i][2] * x[i][1]^x[i-1][2] for i = 2:2:endof(x)])
end

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

Answer 10

दरअसल, 15 बाइट्स

w`i;r♂Pí1^Pn`Mπ

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

स्पष्टीकरण:

w`i;r♂Pí1^Pn`Mπ
w                prime factorization
 `          `M   map (for (p,e) in factorization):
  i;               flatten, make a copy of p
    r♂P            [prime[i] for i in range(p)]
       í           index (essentially the 0-based prime index of p)
        1^         XOR with 1
          P        prime[n]
           n       repeat e times
              π  product

Answer 11

05AB1E, 22 बाइट्स

Ó¾‚˜2ô€R˜DgL<Ø)øvy`smP

व्याख्या की

Ó¾‚˜                    # list of primeexponents with a 0 appended: n=10 -> [1,0,1,0] 
    2ô                  # split into pairs: [[1,0],[1,0]]
      €R˜               # reverse each pair and flatten: [0,1,0,1]
         DgL<Ø          # get list of primes corresponding to the exponents: [2,3,5,7]
              )ø        # zip lists: [[0,2],[1,3],[0,5],[1,7]]
                vy`sm   # raise each prime to its new exponent: [1,3,1,7]
                     P  # product: 21

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

Answer 12

जे, 21 बाइट्स

([:,_2|.\,&0)&.(_&q:)

शून्य के साथ प्रमुख शक्तियों के रूप में n के प्रमुख प्रतिपादक हो जाते हैं । फिर उन्हें एक अतिरिक्त शून्य से भरते हुए आकार 2 के नॉनओवरलैपिंग सब्लिस्ट में विभाजित करें। फिर प्रत्येक सबलिस्ट को रिवर्स करें, और उन्हें एक सूची में समतल करें। अंत में, प्राइम एक्सपोर्टर से एक नंबर में वापस कन्वर्ट करें।

प्रयोग

   f =: ([:,_2|.\,&0)&.(_&q:)
   (,.f"0) 1 2 3 10 37 360 12345
    1     1
    2     3
    3     2
   10    21
   37    31
  360   756
12345 11578
   f 67895678x
125630871

व्याख्या

([:,_2|.\,&0)&.(_&q:)  Input: n
                _&q:   Obtain the list of prime exponents
(           )&.        Apply to the list of prime exponenets
         ,&0           Append a zero to the end of the list
    _2  \              Split the list into nonoverlapping sublists of size 2
      |.               Reverse each sublist
 [:,                   Flatten the list of sublists into a list
             &.(    )  Apply the inverse of (Obtain the list of prime exponents)
                       to convert back to a number and return it