Tôi biết, tôi biết, nhưng một thách thức số nguyên tố khác ...

Liên quan

Một số nguyên tố cô đơn (hoặc cô lập) là một số nguyên tố pnhư vậy p-2, p+2, p-4, p+4... p-2k, p+2kđối với một số kđều composite. Chúng tôi gọi một số nguyên tố như vậy là một số nguyên tố kcô lập lần thứ ba.

Ví dụ, một số nguyên tố cách ly 5 lần là 211vì tất cả 201, 203, 205, 207, 209, 213, 215, 217, 219, 221đều là hợp số. ( p-2*5=201, p-2*4=203, Vv)

Thử thách

Cho hai số nguyên đầu vào, n > 3và k > 0, xuất ra ksố nguyên tố cách ly lần thứ nhất nhỏ hơn lớn hơn n.

Ví dụ, cho k = 5và bất kỳ ntrong phạm vi nào 4 ... 210, đầu ra phải là 211, vì đó là số nguyên tố cách ly 5 lần nhỏ nhất lớn hơn nhiều so với đầu vào n.

Ví dụ

n=55 k=1
67

n=500 k=1
503

n=2100 k=3
2153

n=2153 k=3
2161

n=14000 k=7
14107

n=14000 k=8
14107

Quy tắc

• Nếu có thể, bạn có thể giả sử rằng đầu vào / đầu ra sẽ phù hợp với loại Số nguyên gốc của ngôn ngữ của bạn.
• Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện .
• Hoặc là một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Thạch , 17 13 byte

_æR+⁼ḟ
‘ç1#Ḥ}

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

‘ç1#Ḥ}  Main link. Left argument: n. Right argument: k

‘       Increment; yield n+1.
    Ḥ}  Unhalve right; yield 2k.
 ç1#    Call the helper link with arguments m = n+1, n+2, ... and k until 1 one
        them returns a truthy value. Return the matching [m].


_æR+⁼ḟ  Helper link. Left argument: m. Right argument: k

_       Subtract; yield m-2k.
   +    Add; yield m+2k.
 æR     Prime range; yield the array of primes in [m-2k, ..., m+2k].
     ḟ  Filterfalse; yield the elements of [m] that do not occur in [k], i.e., [m]
        if m ≠ 2k and [] otherwise.
        The result to the left will be non-empty when m = 2k, as there always is
        a prime in [0, ..., 2m], since m > n > 3.
    ⁼   Test the results to both sides for equality.
        This yields 1 iff m is the only prime in [m-2k, ..., m+2k].

Husk , 13 byte

ḟ§=;ofṗM+ṡD⁰→

Hãy thử trực tuyến!

Giải trình

Khá đơn giản.

ḟ§=;ofṗM+ṡD⁰→  Inputs are k and n.
            →  Increment n
ḟ              and find the first number m >= n+1 such that:
         ṡD⁰    Take symmetric range [-2k,..,2k].
       M+       Add m to each.
    ofṗ         Keep those that are prime.
 §=             Check equality with
   ;            the singleton [m].

Java 8, 144 143 byte

(n,k)->{for(k*=2;;)if(p(++n)>1){int i=-k;for(;i<=k&p(n+i)<2|i==0;i+=2);if(i>k)return n;}}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Giải trình:

Hãy thử trực tuyến.

(n,k)->{                      // Method with two integer parameters and integer return-type
  for(k*=2;                   //  Multiply `k` by 2
      ;)                      //  Loop indefinitely
    if(p(++n)>1){             //   Increase `n` by 1 before every iteration with `++n`
                              //   And if it's a prime:
      int i=-k;for(;i<=k      //    Loop `i` from `-k` to `k` (inclusive)
        &p(n+i)<2|i==0;       //    As long as `n+i` is not a prime (skipping `n` itself)
        i+=2);                //    And iterate in steps of 2 instead of 1
      if(i>k)                 //    If we've reached the end of the loop:
        return n;}}           //     We've found our result, so return it

// Separated method to check if `n` is a prime
// `n` is a prime if it remained unchanged, and not when it became 0 or 1
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Python 2 , 105 104 byte

^{-1 byte nhờ vào lò nướng}

n,k=input()
n+=1
while sum(all(x%i for i in range(2,x))^(x==n)for x in range(n-k*2,2*k-~n)):n+=1
print n

Hãy thử trực tuyến!

Stax , 14 byte

åΣ▀ë F▬&■º↔╔^∞

Chạy và gỡ lỗi nó

Đây là đại diện ascii tương ứng.

w^x:r{Hn+|p_!=m0#

w                   while; run the rest of the program until a falsy value remains
 ^                  increment candidate value.
  x:r               [-x, ..., -1, 0, 1, ... x] where x is the first input
     {        m     map using block, using k from -x to x
      Hn+           double and add to candidate value - this is "p+2k"
         |p         is it prime? produces 0 or 1
           _!       k is zero?
             =      two values are equal; always true for a passing candidate
               0#   any falses left after mapping? if so, continue running

JavaScript (Node.js) , 94 92 89 byte

f=(n,k)=>(Q=y=>y<-k||(P=(a,b=2)=>a>b?a%b&&P(a,b+1):1)(n+2*y)^!!y&&Q(--y))(k,++n)?n:f(n,k)

Hãy thử trực tuyến!

Một cách bí ẩn, những sân golf xa hơn kết thúc. Chỉ điều này hoạt động ở kích thước 14000.

Cuối cùng, một sân golf sẽ không kết thúc tràn vào lúc 14000.

Giải trình

f=(n,k)=>            // Two inputs
 (Q=y=>              // Function checking whether all numbers in 
                     // [n-2*k, n+2*k] except n are all composite
  y<-k               // The counter runs from k to -k
                     // If none breaks the rule, return true
  ||(P=(a,b=2)=>     // Function checking primality
   a>b?              // Check if a>b
   a%b&&P(a,b+1)     // If a>b and a%b==0 return false, else proceed
   :1                // If a<=b return 1 (prime)
  )(n+2*y)^!!y       // If n+2*y is prime, then y must be 0
                     // If n+2*y is not prime, then y must be non-zero
                     // If none of the conditions are met, return false
  &&Q(--y)           // Else proceed to the next counter
 )
 (k,++n)?            // Add 1 to n first, then start the check
 n                   // If conditions are met, return n
 :f(n,k)             // Else proceed to the next n.

C (gcc) , 113 byte

P(n,d,b){for(b=d=n>1;++d<n;)b=b&&n%d;n=b;}f(n,k,i,f){for(f=n;f;)for(f=i=!P(++n);i++<k;f|=P(n+i+i)|P(n-i-i));f=n;}

Hãy thử trực tuyến!

Ruby + -rprime, 73 71 61 57 byte

->n,k{n+=1;(-k..k).all?{|i|(i*2+n).prime?^(i!=0)}?n:redo}

Hãy thử trực tuyến!

Cảm thấy tốt khi được học! Tôi đang sử dụng Integer#[]và các redokỹ thuật mà tôi đã học được ở đây trên PPCG. bị lạc trong cỏ dại của các kỹ thuật thú vị ...

-1 byte: Sử dụng n%2thay vì n[0]để có được bit ít quan trọng nhất. Cảm ơn, Asone Tuhid !

-1 byte: Sử dụng toán tử ternary thay cho biểu thức boolean. Cảm ơn, Asone Tuhid !

-10 byte: Sử dụng toán tử XOR để tránh gõ .prime?hai lần ... Đây là câu trả lời của Asone Tuhid nhiều như tôi bây giờ :)

-4 byte: Không có hại trong việc kiểm tra các giá trị chẵn của n. Asone Tuhid là không ngừng.

Ung dung:

->n,k{
  n += 1;                   # Increment n
  (-k..k).all?{|i|          # In the set [n-2*k, n+2*k], is every number
    (i*2+n).prime? ^ (i!=0) #    EITHER prime XOR different from n itself?
  } ? n                     # If yes, return the current value of n
  : redo                    # Otherwise, restart the block
}

Pari / GP , 55 byte

f(n,k)=until(isprime(n++)&&#primes([n-2*k,n+2*k])<2,);n

Hãy thử trực tuyến!

Perl 6 , 63 byte

{$^k;first {[grep *.is-prime,$_-2*$k..$_+2*$k]eqv[$_]},$^a^..*}

Hãy thử trực tuyến!