Đọc này nếu bạn bối rối.

Thử thách:

Mục tiêu của môn đánh gôn này dựa trên số 8675309...

Mục tiêu của bạn là in ra mọi số nguyên tố từ 2 đến 8675309, bắt đầu bằng số 2 và sau đó bỏ qua 8 số nguyên tố, sau đó bỏ qua 6, sau đó bỏ qua 7, v.v. Thực chất, bỏ qua một số số nguyên tố được xác định bởi số tiếp theo trong trình tự 8675309. Đạp xe đến 8 khi nó đạt 9.

Đầu ra:

2
29

(bỏ qua 8 để đến vị trí thứ 10)

59

(bỏ qua 6 để đến vị trí thứ 17)

97

(bỏ qua 7 để đến vị trí thứ 25)

Ví dụ: (Mã giả giống như PHP trong đó $primelà một mảng chứa tất cả các số nguyên tố.)

$tn=1;
$c=1;
$na=array(8,6,7,5,3,0,9);
l:
output($prime[$tn]);
if ($prime[$tn]>=8675309) {exit(8675309)};
$c+=1;
if ($c>=8) {$c=1};
$tn+=$na[$c];
goto l;

Khi tôi nói bỏ qua 8 số nguyên tố, tôi có nghĩa là đi từ số nguyên tố số 1, đến số nguyên tố số 10 (bỏ qua số 8 ở giữa).

Mỗi số phải nằm trên một dòng mới.

Khi bạn đạt đến 0ở 8675309, chỉ cần chỉ in các số nguyên tố tiếp theo mà không bỏ qua bất kỳ.

Đây là mã golf, vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng.

Toán học 67 byte

Không đạt 8675309 mặc dù - không chắc chắn về ý định của OP về điều này.

Column@FoldList[NextPrime,2,Flatten@Array[{9,7,8,6,4,1,10}&,12937]]

Kỳ quan , 47 byte

P\tk582161P;(_>@(os tk1P;P\dp +1#0P))cyc8675309

Ôi trời, cái này càng ngày càng chậm khi thời gian trôi qua ...

Giải trình

P\tk582161P;

Lấy 582161 (số lượng số nguyên tố <= 8675309) từ danh sách số nguyên tố vô hạn Pvà kết quả được tính lại như P.

(_>@(...))cyc8675309

Vô hạn chu kỳ các chữ số của 8675309 và thực hiện một thời gian trên danh sách kết quả.

os tk1P;P\dp +1#0P

Xuất mục đầu tiên vào P, thả cycle item + 1các phần tử từ P và kết quả lại P. Hoạt động này Pcũng hoạt động như một giá trị thật cho thời gian; nếu danh sách trống / giả (có nghĩa là chúng tôi đã đạt 8675309), thì chúng tôi sẽ ngừng lấy từ danh sách đã đạp.

Triển khai nhanh hơn (để thử nghiệm)

P\tk582161P;(_>@(os tk1P;P\dp +1#0P;#0))cyc8675309

Vẫn thực sự chậm, nhưng đáng chú ý là nhanh hơn.

Thạch , 23 29 24 byte

+6 byte cho một bản vá tạm thời để đáp ứng yêu cầu in 8675309.
-5 byte di chuyển đến một người chơi gôn nhưng cách tiếp cận chậm hơn để giải quyết điều đó.

“⁹Ṁ:’©D‘ẋ“2Ṿ’R®ÆR¤ṁḢ€;®Y

Bây giờ quá chậm để chạy trên TryItOnline, nhưng nó chạy cục bộ trong vài phút, tạo ra các số được hiển thị bên dưới với nguồn cấp dữ liệu ở giữa (# số nguyên tố được bỏ qua hiển thị bên dưới trong ngoặc đơn):

2, 29, 59, 97, 127, 149, 151, 199, 257, 293, 349, 383, 409, 419, ...
 (8) (6) (7) (5)  (3)  (0)  (9)  (8)  (6)  (7)  (5)  (3)  (0)

..., 8674537, 8674727, 8674867, 8675003, 8675053, 8675113, 8675137, 8675309
            (8)      (6)      (7)      (5)      (3)      (0)      (4)*

* cuối cùng chỉ là một sự bỏ qua hiệu quả của 4, vì nó chỉ được thêm vào danh sách.

Nhấp vào đây để xem phiên bản sử dụng 3659 thay vì 8675309, có 19 bộ bốn lần bỏ qua (thay vì 12937 bộ 7) và nối thêm 3659 (bỏ qua hiệu quả là 6).

Làm sao?

“⁹Ṁ:’©D‘ẋ“2Ṿ’R®ÆR¤ṁḢ€;®Y - Main link: no arguments
“⁹Ṁ:’                    - base 250 number: 8675309
     ©                   - save in register
      D                  - convert to a decimal list: [8, 6, 7, 5, 3, 0, 9]
       ‘                 - increment: [9,7,8,6,4,1,10]
         “2Ṿ’            - base 250 number: 12937
        ẋ                - repeat: [9,7,8,6,4,1,10,9,7,8,6,4,1,10, ... ,9,7,8,6,4,1,10]
             R           - range (vectorises) [[1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7], ...]
                 ¤       - nilad followed by link(s) as a nilad
              ®          - retrieve value from register: 8675309
               ÆR        - prime range [2,3,5,7, ... ,8675309]
                  ṁ      - mould the primes like the range list:
                               [[2,3,5,7,11,13,17,19,23],[29,31,37,41,43,47,53],...]
                   Ḣ€    - head €ach: [2,29,59,97,127,149,151,199, ..., 8675137]
                      ®  - retrieve value from register: 8675309
                     ;   - concatenate: [2,29,59,97,127,149,151,199, ..., 8675137, 8675309]
                       Y - join with line feeds
                         - implicit print

Ruby, 121 byte

Trailing newline ở cuối tập tin không cần thiết và không được bảo vệ.

P=[]
(2..8675309).map{|c|s=1;P.map{|p|s*=c%p};P<<c if s!=0}
S=[9,7,8,6,4,1,10]*P[-1]
while y=P[0]
p y
P.shift S.shift
end

Giải thích: Plà một mảng các số nguyên tố. clà một ứng cử viên chính; slà sản phẩm của dư lượng modulo mỗi nguyên tố nhỏ hơn; nếu bất kỳ dư lượng nào như vậy bằng 0 (biểu thị đó clà tổng hợp), strở thành (và ở lại) bằng không.

Bộ tạo số nguyên tố chậm. Nó sẽ mất một thời gian looooong để chạy. Kiểm tra đã được thực hiện bằng cách thay thế một Pmảng được tạo ra bằng các phương tiện hiệu quả hơn (cụ thể là ngắn mạch trên phân chia chẵn và nó cũng giúp rất nhiều để dừng kiểm tra tại căn bậc hai).

Haskell, 122 byte

Đây có thể là những gì được yêu cầu:

s(a:b)=a:s[c|c<-b,c`mod`a>0]
f(a:b)(s:t)=a:f(drop s b)t
main=mapM print$takeWhile(<8675310)$f(s[2..])$cycle[8,6,7,5,3,0,9]

Tôi có thể lưu một vài byte bằng cách tính trước số lượng cần thiết và thay thế takeWhilebằng take. Điều đó cũng sẽ cho phép thích ứng với bất kỳ quyết định nào về số cuối cùng được đưa ra. Nó đã in số lượng lên tới 600000 bằng cách sử dụng rất ít bộ nhớ trong thử nghiệm của tôi, vì vậy tôi nghĩ rằng nó có thể đi được tất cả các cách.

Haskell, 109 byte

(p:z)%(x:r)=print p>>(drop x z)%r
p%x=pure()
[n|n<-[2..8675309],all((>0).mod n)[2..n-1]]%cycle[8,6,7,5,3,0,9]

Hãy thử trực tuyến! (cắt ngắn 8675309để 8675, nếu không nó lần ra vào Thử trực tuyến )

Sử dụng:

* Chính> [n | n0) .mod n) [2..n-1]]% chu kỳ [8,6,7,5,3,0,9]
2
29
59
97
127
149
151
199
257
293
349
383
409
419
469
541
587
631
661
691
701
769
829
881
941
983
1013
...

Perl 6 ,  65 73  67 byte

$_=8675309;.[0].put for (2..$_).grep(*.is-prime).rotor(1 X+.comb)

(không thể in 8675137 vì thiếu :partial)

$_=8675309;.[0].put for ^$_ .grep(*.is-prime).rotor((1 X+.comb),:partial)

$_=8675309;.[0].put for ^($_+33) .grep(*.is-prime).rotor(1 X+.comb)

Bằng cách dịch chuyển phần cuối của Phạm vi, :partialcó thể loại bỏ.

Hãy thử nó (thêm giới hạn 5 giây) Xem kết thúc

Ví dụ ban đầu được tính thời gian ở phút 52 phút 41.464 giây.

Mở rộng:

$_ = 8675309;

  .[0]              # get the first value out of inner list
  .put              # print with trailing newline

for                 # for every one of the following

  ^($_+33)          # the Range ( add 33 so that ｢.rotor｣ doesn't need ｢:partial｣ )
  .grep(*.is-prime) # the primes
  .rotor(
    1 X+ .comb      # (1 X+ (8,6,7,5,3,0,9)) eqv (9,7,8,6,4,1,10)
  )

Kết quả của rotorcuộc gọi là chuỗi sau

(
 (  2   3   5   7  11  13  17  19  23)     #  9 (8)
 ( 29  31  37  41  43  47  53)             #  7 (6)
 ( 59  61  67  71  73  79  83  89)         #  8 (7)
 ( 97 101 103 107 109 113)                 #  6 (5)
 (127 131 137 139)                         #  4 (3)
 (149)                                     #  1 (0)
 (151 157 163 167 173 179 181 191 193 197) # 10 (9)

 (199 211 223 227 229 233 239 241 251)     #  9 (8)
 (257 263 269 271 277 281 283)             #  7 (6)
 (293 307 311 313 317 331 337 347)         #  8 (7)
 (349 353 359 367 373 379)                 #  6 (5)
 (383 389 397 401)                         #  4 (3)
 (409)                                     #  1 (0)
 (419 421 431 433 439 443 449 457 461 463) # 10 (9)

 ...
)

Befunge, 136 byte

p2>:1>1+:"~"%55p:"~"/45p:*\`!v
1+^<+ 1<_:#!v#%+g55@#*"~"g54:_\:!#v_1-\
p00%7+1: ,+64g00.:_^#!`***"'(CS":$<^0-"/"g4
>5g#*^#"~"g5<
8675309

Hãy thử trực tuyến! , nhưng lưu ý rằng nó sẽ hết thời gian dài trước khi nó kết thúc. Một phiên bản được biên dịch trên máy cục bộ của tôi hoàn thành trong vòng dưới 10 giây.

Giải trình

Để kiểm tra tính nguyên thủy, chúng tôi lặp lại phạm vi từ 2 đến sqrt ( n ) và kiểm tra xem n có phải là bội số của bất kỳ giá trị nào không - nếu không, đó là số nguyên tố. Quá trình này phức tạp bởi thực tế là giá trị lặp lại cần được lưu trữ trong một "biến" tạm thời và do các ô nhớ của Befunge bị giới hạn về kích thước, nên lưu trữ phải được chia thành hai ô. Để xử lý các số nguyên tố bị bỏ qua, chúng tôi sử dụng "bảng" tra cứu (mà bạn có thể thấy trên dòng 5) để theo dõi các phạm vi khác nhau cần được bỏ qua.

Tôi sẽ không làm một phân tích chi tiết về mã, bởi vì có khá nhiều mã xen kẽ với các lệnh được chia sẻ trên các đường dẫn mã khác nhau để tiết kiệm không gian. Điều này làm cho mọi thứ khá khó theo dõi và tôi không nghĩ nó sẽ đặc biệt thú vị với bất kỳ ai chưa quen thuộc với Befunge.

Đầu ra mẫu

2
29
59
97
127
149
151
199
...
8674397
8674537
8674727
8674867
8675003
8675053
8675113
8675137

Bash (+ lõi), 98, 94 byte

CHỈNH SỬA:

• Bộ lọc hàng được tối ưu hóa một chút, -4 byte

Chơi gôn

seq 8675309|factor|grep -oP "^.*(?=: \S*$)"|sed 1b\;`printf '%d~45b;' {10,17,25,31,35,36,46}`d

Kiểm tra

>seq 8675309|factor|grep -oP "^.*(?=: \S*$)"|sed 1b\;`printf '%d~45b;' {10,17,25,31,35,36,46}`d| head -25
2
29
59
97
127
149
151
199
257
293
349
383
409
419
467
541
587
631
661
691
701
769
829
881
941

Dùng thử trực tuyến! (giới hạn ở N <1000, để làm cho nó chạy nhanh)

Phiên bản đầy đủ mất khoảng 15 giây để hoàn thành trên máy của tôi.