प्राकृतिक संख्याओं के भीतर एक ऐसी आपत्ति दर्ज करें, जो प्राइम्स को प्राइम्स के उचित उपसमुच्चय में मैप करती है

Question

परिभाषाएं

• एक द्विभाजन एक सेट से Sएक सेट के लिए Tसे एक समारोह है Sकरने के लिए Tऐसी है कि एक तत्व में Tमें वास्तव में एक ही तत्व से मैप किया गया है S।

• एक सेट के भीतर एक S से एक आक्षेप एक से आपत्ति Sहै S।

• प्राकृतिक संख्या पूर्णांक जो अधिक से अधिक कर रहे हैं या करने के लिए बराबर हैं 0।

• एक सेट का सबसेट एक सेट ऐसा होता है , जिसमें सेट Sका प्रत्येक तत्व भी होता है S।

• एक समुच्चय का समुच्चयS एक समुच्चय है Sजो एक उपसमुच्चय है जिसके बराबर नहीं है S।

कार्य

एक प्रोग्राम / फ़ंक्शन लिखें जो एक प्राकृतिक संख्या को इनपुट के रूप में लेता है और एक प्राकृतिक संख्या को आउटपुट करता है। यह एक आक्षेप होना चाहिए, और कार्यक्रम / समारोह के तहत primes की छवि {f(p) : p ∈ ℙ}, का एक उचित सबसेट होना चाहिए ℙ, जहां ℙप्रमुख संख्याएं हैं।

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं ।

Comments

मूल CMC (मेरे द्वारा भी)

— लीक नून

Answer 1

गणितज्ञ, ५४ ४ 54 बाइट्स

±(t=x_?PrimeQ)=NextPrime@x
±n_:=Abs[n-1]/.t:>x-1

निम्नलिखित आक्षेप को परिभाषित करता है:

 n  0, 1, 2, 3, 4, 5, 6,  7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, ...
±n  1, 0, 3, 5, 2, 7, 4, 11, 6, 8,  9, 13, 10, 17, 12, 14, 15, 19, ...

मूल विचार प्रत्येक प्राइम को अगले पर मैप करना है, यह सुनिश्चित करने के लिए कि उन्हें उचित सबसेट में मैप किया गया है। यह 2 में एक "अंतर" के रूप में परिणत होता है । उस गैप को भरने के लिए, हम 4 से 2 और फिर पिछले कंपोजिट नंबर पर एक दूसरे को कंपोजिट मैप को "बबल अप" करने के लिए मैप करना चाहते हैं । चूंकि 2 और 3 केवल दो आसन्न अपराध हैं, इसलिए हम उन दोनों मैपिंग को " n-1 या यदि यह एक प्रमुख है तो n-2 " के रूप में व्यक्त कर सकते हैं । अंत में, यह मानचित्रण 1 से 0 भेजना समाप्त कर देता है और हम इसे n-1 का निरपेक्ष मान लेकर 0 को 1 पर भेजते हैं ।

Comments

क्या आपको नक्शे की आवश्यकता है 0?

— नील

@ नील मैं करता हूं, लेकिन मैंने वैसे भी अब आपत्ति बदल दी है।

— मार्टिन एंडर

Answer 2

MATL , 21 बाइट्स

गलती सुधारने के लिए एमिगा को धन्यवाद , अब सही किया गया

tZp?_Yq}q:Zp~fX>sG~E+

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

यह निम्नलिखित आक्षेप को लागू करता है। एक पंक्ति में primes लिखें और नीचे दिए गए गैर-primes:

2  3  5  7 11 13 17 ...
0  1  4  6  8  9 10 ...

फिर इनपुट से तीर का अनुसरण करके आउटपुट प्राप्त किया जाता है:

2 > 3 > 5 > 7 > 11 > 13 > 17 ...
^
0 < 1 < 4 < 6 <  8 <  9 < 10 ...

समझाया गया कोड

t       % Implicit input. Duplicate
Zp      % Is it a prime? Gives true / false
?       % If so
  _Yq   %   Next prime
}       % Else
  q     %   Subtract 1
  :     %   Range from 1 to that
  Zp~   %   Is each entry not a prime? Gives an array of true / false
  f     %   Find non-zero entries, i.e. non-primes. Will be empty for input 1
  X>    %   Maximum. This gives the greatest non-prime less than the input.
        %   Will be empty for input 1
  s     %   Sum. This is to transform empty into 0
  G~E   %   Push input, negate, times 2. This gives 2 for input 0, or 0 otherwise
  E     %   Add. This handles the case of input 0, so that it outputs 2
        % End (implicit). Display (implicit)

Answer 3

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

Æn’’ÆP¿$ÆP?2¹?

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

लुइस के एल्गोरिथ्म का उपयोग करता है।

Answer 4

जावास्क्रिप्ट (ईएस 6), 82 77 75 बाइट्स

लुइस मेंडो के जवाब के समान तर्क लागू करता है ।

f=(n,i=(P=(n,x=n)=>n%--x?P(n,x):x==1||-1)(x=n))=>x?x==n|P(n)-i?f(n+i,i):n:2

प्रारूपित और टिप्पणी की गई

f = (                   // given:
  n,                    // - n = input
  i =                   // - i = 'direction' to move towards
    (P = (n, x = n) =>  // - P = function that returns:
      n % --x ?         //   - 1 when given a prime
        P(n, x)         //   - -1 when given a composite number
      :                 //
        x == 1 || -1    //
    )(x = n)            // - x = copy of the original input
) =>                    //
  x ?                   // if the input is not zero:
    x == n | P(n) - i ? //   if n equals the input or doesn't match its primality:
      f(n + i, i)       //     do a recursive call in the chosen direction
    :                   //   else:
      n                 //     return n
  :                     // else:
    2                   //   return 2

डेमो

f=(n,i=(P=(n,x=n)=>n%--x?P(n,x):x==1||-1)(x=n))=>x?x==n|P(n)-i?f(n+i,i):n:2

for(n = 0; n < 50; n++) {
  console.log(n, '->', f(n));
}

Answer 5

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

Æn_ḍ@¡ÆP?2»0

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

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

Æn_ḍ@¡ÆP?2»0  Main link. Argument: n (non-negative integer)

      ÆP?     If the input is prime:
Æn                Compute the next prime after n.
              Else:
   ḍ@¡   2        Do once if n is divisible by 2, zero times if not.
  _      2        Subtract 2.
              So far, we've mapped all primes to the next prime, all even integers
              (except 2) to the previous even integer, and all composite, odd,
              positive integers to themselves. In particular, 0 -> 2, but 0 doesn't
              have a preimage, so we need 0 -> 0.
          »0  Take the maximum of the result and 0, mapping 0 -> max(-2, 0) = 0.

Comments

उम्म, कृपया एक स्पष्टीकरण जोड़ें?

— आउटगोल्फर

@EriktheOutgolfer जोड़ा गया।

— डेनिस

अच्छा, अब और लोग इस झंझट को समझ सकते हैं ... जो वास्तव में बहुत स्पष्ट है कि मैंने ऐसा क्यों नहीं सोचा?

— निकोल आउटफॉलर