Nhiệm vụ sắp tới là, đưa ra một số n, tìm số nguyên tố nhỏ nhất bắt đầu bằng AT LEAST n của số 2ở đầu số. Đây là một chuỗi tôi tìm thấy trên OEIS ( A068103 ).

17 số đầu tiên trong chuỗi được đưa ra dưới đây, nếu bạn muốn nhiều hơn tôi sẽ thực sự phải thực hiện chuỗi, điều mà tôi không ngại làm.

0  = 2
1  = 2
2  = 223
3  = 2221
4  = 22229
5  = 2222203
6  = 22222223                # Notice how 6 and 7 are the same! 
7  = 22222223                # It must be **AT LEAST** 6, but no more than necessary.
8  = 222222227
9  = 22222222223             # Notice how 9 and 10 are the same!
10 = 22222222223             # It must be **AT LEAST** 9, but no more than necessary.
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221

Chỉ cần nghĩ rằng đây sẽ là một sự kết hợp tuyệt vời của thao tác chuỗi, phát hiện chính và trình tự. Đây là môn đánh gôn , số byte thấp nhất sẽ được tuyên bố là người chiến thắng có thể vào cuối tháng.

Brachylog , 12 11 byte

:2rj:Acb#p=

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

Điều này chuyển thành Brachylog đáng ngạc nhiên trực tiếp. Đây là một hàm, không phải là một chương trình đầy đủ (mặc dù việc đưa trình thông dịch Zlàm đối số dòng lệnh khiến nó thêm trình bao bọc thích hợp để làm cho hàm thành một chương trình; đó là những gì tôi đã làm để làm cho liên kết TIO hoạt động). Điều khá đáng tiếc là jdường như được lập chỉ mục -1 và cần một sự điều chỉnh để cho phép điều đó.

Bạn có thể đưa ra một lập luận hợp lý rằng điều đó =là không cần thiết, nhưng tôi nghĩ rằng nó được đưa ra theo cách của vấn đề, đó là; không có, hàm mô tả tập hợp tất cả các số nguyên tố bắt đầu bằng số 2s đã cho và không có một số tuyên bố rõ ràng mà chương trình nên làm gì đó với mô tả này (trong trường hợp này, tạo giá trị đầu tiên), có lẽ nó không tuân thủ các thông số kỹ thuật.

Giải trình

:2rjbAcb#p=
:2rj         2 repeated a number of times equal to the input plus one
    :Ac      with something appended to it
       b     minus the first element
        #p   is prime;
          =  figure out what the resulting values are and return them

Khi được sử dụng như một hàm trả về một số nguyên, không có gì yêu cầu các giá trị vượt quá đầu tiên, vì vậy đầu tiên là tất cả những gì chúng ta phải lo lắng.

Một sự tinh tế (được chỉ ra trong các ý kiến): :Acbvà b:Actương đương về mặt toán học (khi một cái loại bỏ từ đầu và cái kia thêm vào cuối, với vùng ở giữa không bao giờ trùng nhau); Trước đây tôi đã có b:Ac, điều này tự nhiên hơn, nhưng nó phá vỡ đầu vào 0 (điều mà tôi đoán là do ctừ chối nối danh sách trống với bất kỳ thứ gì; nhiều lý do của Brachylog có xu hướng phá vỡ danh sách trống vì một số lý do). :Acbđảm bảo rằng ckhông bao giờ phải xem danh sách trống, có nghĩa là trường hợp đầu vào 0 cũng có thể hoạt động.

Java (OpenJDK 8) , 164 110 byte

a->{int i=0;for(;!(i+"").matches("2{"+a+"}.*")|new String(new char[i]).matches(".?|(..+)\\1+");i++);return i;}

Cảm ơn @FryAmTheEggman cho một loạt các byte!

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

Bình thường, 12 byte

f&!x`T*Q\2P_

Trong mã giả:

f                key_of_first_truthy_value( lambda T:
  !                  not (
   x`T*Q\2               repr(T).index(input()*'2')
                     )
 &                   and
          P_T        is_prime(T)
                 )

Vòng lặp lambdabắt đầu từ T=1, tăng thêm 1 cho đến khi điều kiện được thỏa mãn. Chuỗi của 2s phải là một chuỗi con từ đầu chuỗi, tức là phương thức chỉ mục cần trả về 0. Nếu không tìm thấy chuỗi con, nó trả về -1một cách thuận tiện cũng là sự thật, vì vậy không có trường hợp ngoại lệ nào tồn tại.

Bạn có thể thử trực tuyến tại đây , nhưng máy chủ chỉ cho phép tối đa đầu vào 4.

Perl, 50 byte

49 byte mã + -pcờ.

++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{

Cung cấp đầu vào mà không có dòng mới cuối cùng. Ví dụ:

echo -n 4 | perl -pE '++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{'

Việc này sẽ mất một lúc để chạy một số lớn hơn 4 khi nó kiểm tra mọi số (có 2 bài kiểm tra: lần đầu tiên /^2{$_}/kiểm tra xem có đủ 2 ở đầu không, và lần thứ hai (1x$\)!~/^1?$|^(11+)\1+$/kiểm tra tính nguyên thủy (với hiệu suất rất kém)).

Haskell, 73 byte

f n=[x|x<-[2..],all((>0).mod x)[3..x-1],take n(show x)==([1..n]>>"2")]!!0

Ví dụ sử dụng: f 3-> 2221.

Lực lượng vũ phu. [1..n]>>"2"tạo một danh sách các n 2s được so sánh với các nký tự đầu tiên trong biểu diễn chuỗi của số nguyên tố hiện tại.

Toán học, 103 byte

ReplaceRepeated[0,i_/;!IntegerDigits@i~MatchQ~{2~Repeated~{#},___}||!PrimeQ@i:>i+1,MaxIterations->∞]&

Hàm không tên lấy một đối số nguyên không âm #và trả về một số nguyên. Nó thực sự kiểm tra lần lượt tất cả các số nguyên dương cho đến khi tìm thấy một số nguyên bắt đầu bằng #2 giây và là số nguyên tố. Chậm khủng khiếp cho đầu vào trên 5.

kết quả trước đó: Mathicala, 155 byte

Mathematica sẽ tốt hơn cho việc chơi gôn nếu nó không được gõ mạnh; chúng ta phải chuyển đổi qua lại một cách rõ ràng giữa các kiểu số nguyên / danh sách / chuỗi.

(d=FromDigits)[2&~Array~#~Join~{1}//.{j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}//.{a__,b_,10,c___}->{a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b})]/. 23->2&

Thuật toán này hoạt động trên danh sách các chữ số , thật kỳ lạ, bắt đầu bằng {2,...,2,1}. Miễn là những chữ số đó không phải là chữ số của một số nguyên tố, nó sẽ thêm một chữ số vào chữ số cuối cùng, bằng cách sử dụng quy tắc {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}... và sau đó thực hiện thủ công mang theo chữ số một đến số tiếp theo miễn là bất kỳ chữ số nào các chữ số bằng 10, sử dụng quy tắc {a__,b_,10,c___}->{a,b+1,0,c}... và sau đó, nếu chúng ta đã đi xa đến mức cuối cùng của các chữ cái đầu 2đã biến thành a 3, bắt đầu lại bằng một chữ số khác ở cuối, sử dụng quy tắc {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. Các /. 23->2cuối cùng chỉ sửa chữa các trường hợp đặc biệt, nếu đầu vào là 1: hầu hết các số nguyên tố không thể kết thúc trong 2, nhưng 2có thể. (Một vài lỗi được đưa ra trên đầu vào 0và1 , nhưng hàm tìm được câu trả lời đúng.)

Thuật toán này khá nhanh: ví dụ, trên máy tính xách tay của tôi, chỉ mất chưa đến 3 giây để tính toán rằng số nguyên tố đầu tiên bắt đầu với 1.000 2giây là 22...220521.

Bình thường, 17 byte

f&q\2{<`T|Q1}TPTh

Có vẻ như không thể giải quyết n = 4trực tuyến, nhưng về mặt lý thuyết thì đúng.

Giải trình

               Th    Starting from (input)+1, 
f                    find the first T so that
      <              the first
          Q          (input) characters
         | 1         or 1 character, if (input) == 0
       `T            of T's string representation
     {               with duplicates removed
  q\2                equal "2", 
 &                   and
            }T       T is found in
              PT     the list of T's prime factors.

Perl 6 , 53 byte

{($/=2 x$^n-1)~first {+($/~$_) .is-prime&&/^2/},0..*}

Thử nó

Mở rộng:

{
  ( $/ = 2 x $^n-1 )       # add n-1 '2's to the front (cache in ｢$/｣)
  ~
  first {
    +( $/ ~ $_ ) .is-prime # find the first that when combined with ｢$/｣ is prime
    &&
    /^2/                   # that starts with a 2 (the rest are in ｢$/｣)
  },
  0..*
}

Thạch , 14 byte

D=2×\S:³aÆPµ1#

Rất kém hiệu quả. Hãy thử trực tuyến!

Pyke, 14 byte

.fj`Q\2*.^j_P&

Hãy thử nó ở đây!

.fj            - first number (asj)
   `    .^     -   str(i).startswith(V)
    Q\2*       -    input*"2"
             & -  ^ & V
          j_P  -   is_prime(j)

12 byte sau lỗi và một tính năng mới

~p#`Q\2*.^)h

Hãy thử nó ở đây!

~p           - all the primes
  #       )h - get the first where...
   `    .^   - str(i).startswith(V)
    Q\2*     -  input*"2"

Sage, 69 68 byte

lambda n:(x for x in Primes()if '2'*len(`x`)=>'2'*n==`x`[:n]).next()

Sử dụng một trình tạo để tìm ra thuật ngữ đầu tiên (do đó nhỏ nhất) trong vô số thuật ngữ.

Japt, 20 byte

L²o@'2pU +Xs s1)nÃæj

Kiểm tra nó trực tuyến! Nó hoàn thành trong vòng hai giây trên máy của tôi cho tất cả các đầu vào tối đa 14 và sau đó, nó tự nhiên mất độ chính xác (JavaScript chỉ có độ chính xác số nguyên lên đến 2 ⁵³ ).

Rất cám ơn @obarakon đã làm việc này :-)

Giải trình

                       // Implicit: U = input integer, L = 100
L²o                    // Generate the range [0...100²).
   @             Ã     // Map each item X through the following function:
    '2pU               //   Take a string of U "2"s.
         +Xs s1)n      //   Append all but the first digit of X, and cast to a number.
                       // If U = 3, we now have the list [222, 222, ..., 2220, 2221, ..., 222999].
                  æ    // Take the first item that returns a truthy value when:
                   j   //   it is checked for primality.
                       // This returns the first prime in the forementioned list.
                       // Implicit: output result of last expression

Trong phiên bản mới nhất của Japt, đây có thể là 12 byte:

_n j}b!+'2pU   // Implicit: U = input integer
_   }b         // Return the first non-negative bijective base-10 integer that returns
               // a truthy value when run through this function, but first,
      !+       //   prepend to each integer
        '2pU   //   a string of U '2's.
               // Now back to the filter function:
 n j           //   Cast to a number and check for primality.
               // Implicit: output result of last expression

Kiểm tra nó trực tuyến! Nó hoàn thành trong vòng nửa giây trên máy của tôi cho tất cả các đầu vào lên đến 14.

PHP, 76 byte

for($h=str_pad(2,$i=$argv[1],2);$i>1;)for($i=$p=$h.++$n;$p%--$i;);echo$p?:2;

lấy đầu vào từ đối số dòng lệnh. Chạy với -r.

phá vỡ

for($h=str_pad(2,$i=$argv[1],2) # init $h to required head
    ;$i>1;                      # start loop if $p>2; continue while $p is not prime
)
    for($i=$p=$h.++$n               # 1. $p = next number starting with $h
                                    #    (first iteration: $p is even and >2 => no prime)
    ;$p%--$i;);                     # 2. loop until $i<$p and $p%$i==0 ($i=1 for primes)
echo$p?:2;                      # print result; `2` if $p is unset (= loop not started)

Bash (+ coreutils), 53 byte

Hoạt động tới 2 ^ 63-1 (9223372036854775807) , mất nhiều thời gian để hoàn thành cho N> 8.

Chơi gôn

seq $[2**63-1]|factor|grep -Pom1 "^2{$1}.*(?=: \S*$)"

Kiểm tra

>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

Python 3, 406 byte

w=2,3,5,7,11,13,17,19,23,29,31,37,41
def p(n):
 for q in w:
  if n%q<1:return n==q
  if q*q>n:return 1
 m=n-1;s,d=-1,m
 while d%2==0:s,d=s+1,d//2
 for a in w:
  x=pow(a,d,n)
  if x in(1,m):continue
  for _ in range(s):
   x=x*x%n
   if x==1:return 0
   if x==m:break
  else:return 0
 return 1
def f(i):
 if i<2:return 2
 k=1
 while k:
  k*=10;l=int('2'*i)*k
  for n in range(l+1,l+k,2):
   if p(n):return n

mã kiểm tra

for i in range(31):
    print('{:2} = {}'.format(i, f(i)))

đầu ra thử nghiệm

 0 = 2
 1 = 2
 2 = 223
 3 = 2221
 4 = 22229
 5 = 2222203
 6 = 22222223
 7 = 22222223
 8 = 222222227
 9 = 22222222223
10 = 22222222223
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221
17 = 222222222222222221
18 = 22222222222222222253
19 = 222222222222222222277
20 = 2222222222222222222239
21 = 22222222222222222222201
22 = 222222222222222222222283
23 = 2222222222222222222222237
24 = 22222222222222222222222219
25 = 222222222222222222222222239
26 = 2222222222222222222222222209
27 = 2222222222222222222222222227
28 = 222222222222222222222222222269
29 = 2222222222222222222222222222201
30 = 222222222222222222222222222222053

Tôi quyết định tăng tốc trên một phạm vi khá lớn, thay vì kích thước byte. :) Tôi sử dụng một bài kiểm tra tính nguyên thủy Miller-Rabin xác định được đảm bảo lên tới 3317044064679887385961981 với bộ nhân chứng này. Các số nguyên tố lớn hơn sẽ luôn vượt qua bài kiểm tra thành công, nhưng một số vật liệu tổng hợp cũng có thể vượt qua, mặc dù xác suất rất thấp. Tuy nhiên, tôi cũng đã thử nghiệm những con số đầu ra cho i> 22 sử dụng pyecm một chương trình nhân tử Elliptic Curve, và chúng xuất hiện để được thủ.

Python 3, 132 byte

def f(x):
 k=10;p=2*(k**x//9)
 while x>1:
  for n in range(p*k,p*k+k):
   if all(n%q for q in range(2,n)):return n
  k*=10
 return 2

Bất kỳ hy vọng về hiệu suất đã được hy sinh cho số byte nhỏ hơn.

Java, 163 byte

BigInteger f(int a){for(int x=1;x>0;x+=2){BigInteger b=new BigInteger(new String(new char[a]).replace("\0","2")+x);if(b.isProbablePrime(99))return b;}return null;}

mã kiểm tra

    public static void main(String[] args) {
    for(int i = 2; i < 65; i++)
        System.out.println(i + " " + new Test20170105().f(i));
    }

đầu ra:

2 223
3 2221
4 22229
5 2222219
6 22222223
7 22222223
8 222222227
9 22222222223
10 22222222223
11 2222222222243
12 22222222222229
13 22222222222229
14 222222222222227
15 222222222222222143
16 222222222222222221
17 222222222222222221
18 22222222222222222253
19 222222222222222222277
20 2222222222222222222239
21 22222222222222222222261
22 222222222222222222222283
23 2222222222222222222222237
24 22222222222222222222222219
25 222222222222222222222222239
26 2222222222222222222222222213
27 2222222222222222222222222227
28 222222222222222222222222222269
29 22222222222222222222222222222133
30 222222222222222222222222222222113
31 222222222222222222222222222222257
32 2222222222222222222222222222222243
33 22222222222222222222222222222222261
34 222222222222222222222222222222222223
35 222222222222222222222222222222222223
36 22222222222222222222222222222222222273
37 222222222222222222222222222222222222241
38 2222222222222222222222222222222222222287
39 22222222222222222222222222222222222222271
40 2222222222222222222222222222222222222222357
41 22222222222222222222222222222222222222222339
42 222222222222222222222222222222222222222222109
43 222222222222222222222222222222222222222222281
44 2222222222222222222222222222222222222222222297
45 22222222222222222222222222222222222222222222273
46 222222222222222222222222222222222222222222222253
47 2222222222222222222222222222222222222222222222219
48 22222222222222222222222222222222222222222222222219
49 2222222222222222222222222222222222222222222222222113
50 2222222222222222222222222222222222222222222222222279
51 22222222222222222222222222222222222222222222222222289
52 2222222222222222222222222222222222222222222222222222449
53 22222222222222222222222222222222222222222222222222222169
54 222222222222222222222222222222222222222222222222222222251
55 222222222222222222222222222222222222222222222222222222251
56 2222222222222222222222222222222222222222222222222222222213
57 222222222222222222222222222222222222222222222222222222222449
58 2222222222222222222222222222222222222222222222222222222222137
59 22222222222222222222222222222222222222222222222222222222222373
60 222222222222222222222222222222222222222222222222222222222222563
61 2222222222222222222222222222222222222222222222222222222222222129
62 2222222222222222222222222222222222222222222222222222222222222227
63 2222222222222222222222222222222222222222222222222222222222222227
64 2222222222222222222222222222222222222222222222222222222222222222203

582,5858 mili giây

Giải thích: vòng lặp trên các số nguyên và thêm chúng dưới dạng chuỗi vào chuỗi gốc, là chuỗi "2" đã cho và xác minh xem nó có phải là số nguyên tố hay không.