คำนิยาม

• bijectionจากชุดSการตั้งค่าTฟังก์ชั่นจากSการTองค์ประกอบดังกล่าวว่าหนึ่งในTSแมปโดยองค์ประกอบว่าหนึ่งใน

• bijection ภายในชุด Sเป็น bijection จากSSไป

• หมายเลขธรรมชาติ0เป็นจำนวนเต็มซึ่งเป็นมากกว่าหรือเท่ากับ

• ชุดย่อยของชุดSSคือชุดดังกล่าวว่าองค์ประกอบในชุดที่ทุกคนยังอยู่ใน

• เซตย่อยที่เหมาะสมของชุดSคือชุดที่เป็นส่วนย่อยของซึ่งไม่เท่ากับSS

งาน

เขียนโปรแกรม / ฟังก์ชั่นที่รับจำนวนธรรมชาติเป็นอินพุทและเอาท์พุทจำนวนธรรมชาติ มันจะต้องเป็น bijection และรูปภาพของจำนวนเฉพาะภายใต้โปรแกรม / ฟังก์ชั่น{f(p) : p ∈ ℙ}จะต้องเป็นเซตย่อยที่เหมาะสมℙซึ่งℙเป็นจำนวนเฉพาะ

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์ ช่องโหว่ตามมาตรฐาน

Mathematica, 54 48 ไบต์

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

กำหนด bijection ต่อไปนี้:

 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และเราจะทำให้มันส่ง0กลับไปที่1โดยการค่าสัมบูรณ์ของn-1

MATL , 21 ไบต์

ขอบคุณEmigna ที่ตรวจพบข้อผิดพลาดได้รับการแก้ไขแล้ว

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

ลองออนไลน์!

วิธีนี้จะใช้ไบโอดีต่อไปนี้ เขียนจำนวนเฉพาะในแถวและไม่ใช่ช่วงเวลาด้านล่าง:

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)

เยลลี่ 14 ไบต์

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

ลองออนไลน์!

ใช้อัลกอริทึมของ Luis

JavaScript (ES6), 82 77 75 ไบต์

ดำเนินการตรรกะเดียวกับคำตอบของหลุยส์ Mendo ของ

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

เยลลี่ 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.