ท้าทาย

นี่คือค่าง่ายๆ: กำหนดจำนวนเต็มบวกได้สูงสุด 1,000,000 ส่งคืนจำนวนเฉพาะที่ใกล้เคียงที่สุด

หากตัวเลขนั้นเป็นจำนวนเฉพาะคุณควรส่งคืนหมายเลขนั้น หากมีสองช่วงเวลาใกล้เคียงกับจำนวนที่ระบุให้กลับด้านล่างของทั้งสอง

อินพุตอยู่ในรูปแบบของจำนวนเต็มเดียวและเอาต์พุตควรอยู่ในรูปของจำนวนเต็มเช่นกัน

ฉันไม่สนใจว่าคุณจะใช้อินพุท (ฟังก์ชั่น, STDIN, ฯลฯ ) หรือแสดงเอาท์พุท (ฟังก์ชั่น, STDOUT, ฯลฯ ) ตราบใดที่มันใช้งานได้

นี่คือรหัสกอล์ฟดังนั้นจึงใช้กฎมาตรฐาน - โปรแกรมที่มีจำนวนไบต์น้อยที่สุดชนะ!

กรณีทดสอบ

Input  =>  Output
------    -------
80     =>      79
100    =>     101
5      =>       5
9      =>       7
532    =>     523
1      =>       2

Gaiaขนาด 3 ไบต์

ṅD⌡

ลองออนไลน์!

ค่อนข้างช้าสำหรับอินพุตขนาดใหญ่ แต่ทำงานได้หน่วยความจำ / เวลาเพียงพอ

ฉันไม่แน่ใจว่าทำไมD⌡ผลักzอีกครั้งโดยปริยายแต่มันทำให้คำตอบสั้น ๆ อย่างน่าทึ่ง!

ṅ	| implicit input z: push first z prime numbers, call it P
 D⌡	| take the absolute difference between P and (implicit) z,
	| returning the smallest value in P with the minimum absolute difference

JavaScript (ES6), 53 ไบต์

n=>(g=(o,d=N=n+o)=>N%--d?g(o,d):d-1?g(o<0?-o:~o):N)``

ลองออนไลน์!

แสดงความคิดเห็น

n => (            // n = input
  g = (           // g = recursive function taking:
    o,            //   o = offset
    d =           //   d = current divisor, initialized to N
    N = n + o     //   N = input + offset
  ) =>            //
    N % --d ?     // decrement d; if d is not a divisor of N:
      g(o, d)     //   do recursive calls until it is
    :             // else:
      d - 1 ?     //   if d is not equal to 1 (either N is composite or N = 1):
        g(        //     do a recursive call with the next offset:
          o < 0 ? //       if o is negative:
            -o    //         make it positive (e.g. -1 -> +1)
          :       //       else:
            ~o    //         use -(o + 1) (e.g. +1 -> -2)
        )         //     end of recursive call
      :           //   else (N is prime):
        N         //     stop recursion and return N
)``               // initial call to g with o = [''] (zero-ish)

05AB1E , 5 ไบต์

Åps.x

ลองออนไลน์! หรือเป็นชุดทดสอบ

ไม่มีประสิทธิภาพสำหรับคนจำนวนมาก

อ็อกเทฟ 40 ไบต์

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))

ลองออนไลน์!

สิ่งนี้ใช้ความจริงที่ว่ามีอยู่เสมอระหว่างnและ2*n( ทฤษฎีบทเบอร์แทรนด์ - Chebyshev )

มันทำงานอย่างไร

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))

@(n)                                      % Define anonymous function with input n
                       p=primes(2*n)      % Vector of primes up to 2*n. Assign to p
                abs(n-(             ))    % Absolute difference between n and each prime
      [~,k]=min(                      )   % Index of first minimum (assign to k; not used)
    p(                                 )  % Apply that index to p

Japt , 5 ไบต์

_j}cU

ลองใช้หรือเรียกใช้กรณีทดสอบทั้งหมด

_j}cU     :Implicit input of integer U
_         :Function taking an integer as an argument
 j        :  Test if integer is prime
  }       :End function
   cU     :Return the first integer in [U,U-1,U+1,U-2,...] that returns true

05AB1E , 4 ไบต์

z-Ån

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 31 ไบต์

Nearest[Prime~Array~78499,#,1]&

ลองออนไลน์!

                              & (*pure function*)
        Prime~Array~78499       (*among the (ascending) first 78499 primes*)
                            1   (*select one*)
Nearest[                 ,#, ]  (*which is nearest to the argument*)

1000003 เป็นอันดับที่ 78499 Nearestจัดลำดับความสำคัญของค่าที่ปรากฏก่อนหน้าในรายการ (ซึ่งต่ำกว่า)

Brachylogขนาด7 5 ไบต์

;I≜-ṗ

ลองออนไลน์!

บันทึก 2 ไบต์ด้วย @DLosc

คำอธิบาย

;I≜      Label an unknown integer I (tries 0, then 1, then -1, then 2, etc.)
   -     Subtract I from the input
    ṗ    The result must be prime

Pyth, 10 ไบต์

haDQfP_TSy

ลองออนไลน์ได้ที่นี่หรือตรวจสอบทุกกรณีการทดสอบในครั้งเดียวที่นี่

haDQfP_TSyQ   Implicit: Q=eval(input())
              Trailing Q inferred
         yQ   2 * Q
        S     Range from 1 to the above
    f         Filter keep the elements of the above, as T, where:
     P_T        Is T prime?
  D           Order the above by...
 a Q          ... absolute difference between each element and Q
                This is a stable sort, so smaller primes will be sorted before larger ones if difference is the same
h             Take the first element of the above, implicit print

เยลลี่ , 9 7 ไบต์

ḤÆRạÞµḢ

ลองออนไลน์!

ช้าลงสำหรับการป้อนข้อมูลขนาดใหญ่ แต่ใช้งานได้สำหรับช่วงที่ร้องขอ ขอบคุณ @EriktheOutgolfer สำหรับการบันทึก 2 ไบต์!

Python 2 , 71 ไบต์

f=lambda n,k=1,p=1:k<n*3and min(k+n-p%k*2*n,f(n,k+1,p*k*k)-n,key=abs)+n

ลองออนไลน์!

p$(k-1)!^2$p%kabs(k-n)kk-nabsnkจะได้รับผลที่ตามมา

การแสดงออกk+n-p%k*2*nถูกออกแบบมาเพื่อให้k-nกับจำนวนเฉพาะ (ที่p%k=1) และมิฉะนั้นมูลค่า "ไม่ดี" ของk+nที่ใหญ่กว่าเสมอในค่าสัมบูรณ์และดังนั้นจึงไม่ส่งผลกระทบต่อขั้นต่ำดังนั้นที่ไม่ใช่ช่วงเวลาที่ถูกส่งผ่าน

C (gcc) , 87 76 74 72 ไบต์

การเพิ่มประสิทธิภาพของC #ของ Innat3 (Visual C # Interactive Compiler) ขนาด 100 ไบต์

f(n,i,t,r,m){for(t=0,m=n;r-2;t++)for(r=i=1,n+=n<m?t:-t;i<n;n%++i||r++);}

ลองออนไลน์!

เรียบร้อย 43 ไบต์

{x:(prime↦splice(]x,-1,-∞],[x,∞]))@0}

ลองออนไลน์!

คำอธิบาย

xนี่คือแลมบ์ดากับพารามิเตอร์ สิ่งนี้ทำงานโดยการสร้างลำดับต่อไปนี้:

[x - 1, x, x - 2, x + 1, x - 3, x + 2, x - 4, x + 3, ...]

นี่คือการประกบกันทั้งสองลำดับ]x, -1, -∞](ซ้ายปิดขวาเปิด) และ[x, ∞](เปิดทั้งสอง)

สำหรับx = 80สิ่งนี้ดูเหมือนว่า:

[79, 80, 78, 81, 77, 82, 76, 83, 75, 84, 74, 85, ...]

จากนั้นเราใช้f↦sเพื่อเลือกองค์ประกอบทั้งหมดจากsความพึงพอใจfความพึงพอใจในกรณีนี้เรากรองตัวเลขรวมทั้งหมดโดยเหลือเฉพาะหมายเลขเฉพาะ ในทำนองเดียวกันxสิ่งนี้จะกลายเป็น:

[79, 83, 73, 71, 89, 67, 97, 61, 59, 101, 103, 53, ...]

จากนั้นเราใช้(...)@0เพื่อเลือกสมาชิกรายแรกของลำดับนี้ เนื่องจากจำเป็นต้องเลือกส่วนล่างของทั้งสองลำดับที่เริ่มต้นด้วยx - 1จะถูกต่อด้วยลำดับแรก

หมายเหตุ: มีเพียงหนึ่งxและสามารถเป็นสำคัญดังนั้นจึงเป็นโอเคว่าลำดับแต่งงานจะเริ่มต้นด้วยx - 1 x - 1แม้ว่าลำดับสามารถเปิดได้ทั้งสองด้าน ( [x,-1,-∞]) สิ่งนี้จะไม่จำเป็นรวมxสองครั้งในลำดับ ดังนั้นเพื่อ "ประสิทธิภาพ" ฉันเลือกรุ่นที่ปิดด้านซ้าย (เช่นกันเพราะฉันชอบที่จะแสดงความเป็นระเบียบเรียบร้อย)

ตัวคูณ 91 ไบต์

: p ( x -- x ) [ nprimes ] keep dupd [ - abs ] curry map swap zip natural-sort first last ;

ลองออนไลน์!

APL (Dyalog Extended) , 20 15ไบต์^SBCS

ฟังก์ชั่นคำนำหน้าโดยปริยายแรงบันดาลใจจากเลน Ivanov คำตอบของ

⊢(⊃⍋⍤|⍤-⊇⊢)¯2⍭⍳

ลองออนไลน์!

⍳ ɩ ndices หนึ่งผ่านการโต้แย้ง

¯2⍭ จำนวนที่แน่นอนของที่

⊢(...)  ใช้ฟังก์ชัน tacit ต่อไปนี้กับอาร์กิวเมนต์เดิมเป็นอาร์กิวเมนต์ซ้าย:

 ⊢ ช่วงเวลา

 ⊇ จัดทำดัชนีโดย:

  ⍋ เกรดจากน้อยไปมาก (ดัชนีซึ่งจะเรียงลำดับจากน้อยไปมาก)
  ⍤ ของ
  | ขนาด (ค่าสัมบูรณ์)
  ⍤ ของ
  -  ความแตกต่าง

 ⊃ เลือกอันแรก (เช่นอันที่มีความแตกต่างน้อยที่สุด)

Perl 6 , 35 ไบต์

{$_+=($*=-1)*$++until .is-prime;$_}

ลองออนไลน์!

วิธีนี้ใช้เทคนิคของ Veitcel ในการสร้างรายการ0, -1, 2, -3แต่ลดความซับซ้อนลงอย่างมากในการ($*=-1)*$++ใช้ตัวแปรสถานะไม่ระบุตัวตนที่มีอยู่ใน P6 (แต่เดิมฉันมี-1 ** $++ * $++แต่เมื่อ golfed ลบเชิงลบจะสูญเสียความสำคัญ) มีตัวตรวจสอบเฉพาะในตัว แต่น่าเสียดายที่การuntilป้องกันไม่ให้มูลค่าที่ส่งคืนโดยอัตโนมัติดังนั้นจึงมีการ$_แขวนเพิ่มเติมเป็นพิเศษ

C, 122 121 104 ไบต์

p(a,i){for(i=1;++i<a;)if(a%i<1)return 0;return a>1;}c(a,b){for(b=a;;b++)if(p(--a)|p(b))return p(b)?b:a;}

ใช้มันเรียกฟังก์ชั่นc()และผ่านเป็นอาร์กิวเมนต์หมายเลข; มันควรจะคืนค่านายกที่ใกล้เคียงที่สุด

ขอบคุณศูนย์รวมแห่งความไม่รู้สำหรับ1 ไบต์บันทึกการปรับปรุงใหญ่

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 52 ไบต์

If[PrimeQ[s=#],s,#&@@Nearest[s~NextPrime~{-1,1},s]]&

ลองออนไลน์!

APL (NARS), 38 ตัวอักษร, 76 ไบต์

{⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d}

0πคือการทดสอบสำหรับไพรม์, ¯1 prev ไพร์มก่อนหน้า, 1πคือไพร์มถัดไป; ทดสอบ:

  f←{⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d}
  f¨80 100 5 9 532 1
79 101 5 7 523 2 

J , 19 15 ไบต์

(0{]/:|@-)p:@i.

ลองออนไลน์!

Perl 5 , 59 ไบต์

$a=0;while((1x$_)=~/^.?$|^(..+?)\1+$/){$_+=(-1)**$a*($a++)}

ลองออนไลน์!

/^.?$|^(..+?)\1+$/ เป็น regexp หากินเพื่อตรวจสอบเฉพาะ

(-1)**$a*($a++) สร้างลำดับ 0, -1, 2, -3 ...

MathGolf , 10 ไบต์

∞╒g¶áÅ-±├Þ

ลองออนไลน์

คำอธิบาย:

∞            # Double the (implicit) input-integer
 ╒           # Create a list in the range [1, 2*n]
  g¶         # Filter so only the prime numbers remain
    áÅ       # Sort this list using the next two character:
      -±     #  The absolute difference with the (implicit) input-integer
        ├    # Push the first item of the list
             # (unfortunately without popping the list itself, so:)
         Þ   # Discard everything from the stack except for the top
             # (which is output implicitly as result)

Python 2 (Cython) , 96 ไบต์

l=lambda p:min(filter(lambda p:all(p%n for n in range(2,p)),range(2,p*3)),key=lambda x:abs(x-p))

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 104 100 ไบต์

n=>{int r=0,t=0,m=n;while(r!=2){n+=(n<m)?t:-t;t++;r=0;for(int i=1;i<=n;i++)if(n%i==0)r++;}return n;}

ลองออนไลน์!

คำอธิบาย:

int f(int n)
{
    int r = 0; //stores the amount of factors of "n"
    int t = 0; //increment used to cover all the integers surrounding "n"
    int m = n; //placeholder to toggle between adding or substracting "t" to "n"

    while (r != 2) //while the amount of factors found for "n" is different to 2 ("1" + itself)
    {
        n += (n < m) ? t : -t; //increment/decrement "n" by "t" (-0, -1, +2, -3, +4, -5,...)
        t++;
        r = 0;
        for (int i = 1; i <= n; i++) //foreach number between "1" and "n" increment "r" if the remainder of its division with "n" is 0 (thus being a factor)
            if (n % i == 0) r++; 
    }
    return n;
}

Console.WriteLine(f(80)); //79

ชวา 8, 88 87 ไบต์

n->{for(int c=0,s=0,d,N=n;c!=2;s++)for(c=d=1,n+=n<N?s:-s;d<n;)if(n%++d<1)c++;return n;}

ท่าเรือ@NaturalNumberGuy 's (ตอนแรก) คำตอบ C ,เพื่อให้แน่ใจว่า upvote เขา !!
-1 ขอบคุณไบต์@ OlivierGrégoire

ลองออนไลน์

คำอธิบาย:

n->{               // Method with integer as both parameter and return-type
  for(int c=0,     //  Counter-integer, starting at 0
          s=0,     //  Step-integer, starting at 0 as well
          d,       //  Divisor-integer, uninitialized
          N=n;     //  Copy of the input-integer
      c!=2;        //  Loop as long as the counter is not exactly 2 yet:
      s++)         //    After every iteration: increase the step-integer by 1
    for(c=d=1,     //   (Re)set both the counter and divisor to 1
        n+=n<N?    //   If the input is smaller than the input-copy:
            s      //    Increase the input by the step-integer
           :       //   Else:
            -s;    //    Decrease the input by the step-integer
        d<n;)      //   Inner loop as long as the divisor is smaller than the input
      if(n%++d     //    Increase the divisor by 1 first with `++d`
              <1)  //    And if the input is evenly divisible by the divisor:
        c++;       //     Increase the counter-integer by 1
  return n;}       //  Return the now modified input-integer as result

Java (JDK) , 103 ไบต์

n->{int p=0,x=0,z=n,d;for(;p<1;p=p>0?z:0,z=z==n+x?n-++x:z+1)for(p=z/2,d=1;++d<z;)p=z%d<1?0:p;return p;}

ลองออนไลน์!

Haskell , 79 74 ไบต์ (ขอบคุณ Laikoni)

72 ไบต์เป็นฟังก์ชันแบบไม่ระบุชื่อ (สามารถลบ "f =" เริ่มต้นได้ในกรณีนี้)

f=(!)(-1);n!x|x>1,all((>0).mod x)[2..x-1]=x|y<-x+n=last(-n+1:[-n-1|n>0])!y

ลองออนไลน์!

รหัสเดิม:

f=(!)(-1);n!x|x>1&&all((>0).mod x)[2..x-1]=x|1>0=(last$(-n+1):[-n-1|n>0])!(x+n)

ลองออนไลน์!

คำอธิบาย:

f x = (-1)!x

isPrime x = x > 1 && all (\k -> x `mod` k /= 0)[2..x-1]
n!x | isPrime x = x            -- return the first prime found
    | n>0       = (-n-1)!(x+n) -- x is no prime, continue with x+n where n takes the 
    | otherwise = (-n+1)!(x+n) -- values -1,2,-3,4 .. in subsequent calls of (!)

VDM-SL , 161 ไบต์

f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)({x|x in set{1,...,9**7}&forall y in set{2,...,1003}&y<>x=>x mod y<>0})

โปรแกรมเต็มรูปแบบในการทำงานอาจมีลักษณะเช่นนี้ - มันน่าสังเกตว่าขอบเขตของชุดของช่วงเวลาที่ใช้ควรมีการเปลี่ยนแปลงหากคุณต้องการเรียกใช้งานจริงเนื่องจากใช้เวลานานกว่า 1 ล้านในการรัน:

functions
f:nat1+>nat1
f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)({x|x in set{1,...,9**7}&forall y in set{2,...,1003}&y<>x=>x mod y<>0})

คำอธิบาย:

f(i)==                                        /* f is a function which takes a nat1 (natural number not including 0)*/
(lambda p:set of nat1                         /* define a lambda which takes a set of nat1*/
&let z in set p be st                         /* which has an element z in the set such that */
forall m in set p                             /* for every element in the set*/
&abs(m-i)                                     /* the difference between the element m and the input*/
>=abs(z-i)                                    /* is greater than or equal to the difference between the element z and the input */
in z)                                         /* and return z from the lambda */
(                                             /* apply this lambda to... */
{                                             /* a set defined by comprehension as.. */
x|                                            /* all elements x such that.. */ 
x in set{1,...,9**7}                          /* x is between 1 and 9^7 */
&forall y in set{2,...,1003}                  /* and for all values between 2 and 1003*/
&y<>x=>x mod y<>0                             /* y is not x implies x is not divisible by y*/
} 
)

MATL , 6 ไบต์

t:YqYk

ลองออนไลน์!

รายชื่อแรกจำนวนเฉพาะและหาคนที่อยู่ใกล้nn

C # (Visual C # Interactive คอมไพเลอร์) , 112 ไบต์

g=>Enumerable.Range(2,2<<20).Where(x=>Enumerable.Range(1,x).Count(y=>x%y<1)<3).OrderBy(x=>Math.Abs(x-g)).First()

ลองออนไลน์!

เลื่อนไปทางซ้าย 20 ครั้งในการส่ง แต่ 10 ครั้งใน TIO เพื่อให้ TIO ยกเลิกการทดสอบในกรณี