Những điều cần biết:

Đầu tiên, con số may mắn.

Những con số may mắn được tạo ra như vậy:

Lấy tất cả các số tự nhiên:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20...

Sau đó, loại bỏ từng số thứ hai.

1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39...

Bây giờ, 3là an toàn.

Xóa mọi số thứ 3:

1, 3, 7, 9, 13, 15, 19, 21, 25, 27, 31, 33, 37, 39, 43, 45, 49, 51, 55, 59...

Bây giờ, 7là an toàn.

Xóa mọi số thứ 7.

Tiếp tục và xóa mọi nsố thứ tự, trong đón là số an toàn đầu tiên sau khi loại bỏ.

Danh sách cuối cùng của số an toàn là số may mắn.

Các số không may mắn bao gồm các danh sách riêng biệt của các số [U1, U2, U3... Un].

U1 là bộ số đầu tiên được xóa khỏi "ứng cử viên" may mắn, vì vậy chúng là:

2, 4, 6, 8, 10, 12, 14, 16, 18, 20...

U2 là bộ số thứ hai bị xóa:

5, 11, 17, 23, 29, 35, 41, 47, 53, 59...

Và cứ tiếp tục như vậy ( U3là danh sách thứ ba, U4là thứ tư, v.v.)

Thử thách:

Nhiệm vụ của bạn là, khi được đưa ra hai đầu vào mvà n, tạo msố thứ trong danh sách Un.

Ví dụ đầu vào và đầu ra:

(5, 2) -> 29
(10, 1) -> 20

Thông số kỹ thuật:

• Chương trình của bạn phải hoạt động mtối đa 1e6và ntối đa 100.
  • Bạn được đảm bảo rằng cả hai mvàn là số nguyên dương.
  • Nếu bạn tò mò, U(1e6, 100)= 5,333,213,163. (Cảm ơn bạn @pacholik!)
• Chương trình của bạn phải tính toán trong vòng 1 ngày trên một máy tính hiện đại hợp lý.

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

PS: Sẽ thật tuyệt nếu ai đó nghĩ ra một công thức chung để tạo ra những thứ này. Nếu bạn có một công thức, xin vui lòng đặt nó trong câu trả lời của bạn!

CJam , 74 byte

ri0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A0@{@:B:(_0#):D{D(_A=tD<BD>+}&@)@DU=-}h]1=

Hãy thử trực tuyến! Sẽ hết thời gian cho các trường hợp lớn hơn, nhiều hơn về các hạn chế thời gian dưới đây.

Giải trình:

Chương trình của chúng tôi mượn một cách đáng xấu hổ mã của aditsu để tạo danh sách N số may mắn, thay thế 1 bằng số 2 sẽ tăng dần trong mỗi giai đoạn của sàng. Mã còn lại giảm trên mỗi phần tử cho đến khi tìm thấy số 0 (bằng cách cắt và nối thêm đuôi không giảm) và đếm hiệu quả các bước trong từng giai đoạn của N của sàng.

ri                               e# read M
0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A  e# list steps (also becomes B)
0@                               e# arrange stack [B I M]
{                                e# while M
   @:B                           e#   get current B
   :(                            e#   decrement every element in B
   _0#):D                        e#   find first 0
   {                             e#   if there is a 0
      D(_A=t                     e#     reset that element in B
      D<BD>+                     e#     replace tail after 0
   }&                            e#   end if
   @)                            e#   increment I
   @DU=-                         e#   decrement M if N-th phase of sieve
}h                               e# end loop
]1=                              e# return I

Thời gian:

Nếu bạn hoàn toàn phải chạy chương trình trong trình duyệt với số lượng lớn hơn, bạn có thể sử dụng trình thông dịch này và cho phép tập lệnh tiếp tục nếu được nhắc, nhưng điều này có thể quá chậm để đủ điều kiện. Sử dụng ( M , N ) = (100.100) mất ~ 247 giây. Việc lặp lại các chương trình tương đối tuyến tính theo M , vì vậy tính toán (1e6.100) có thể mất ~ 29 ngày.

Sử dụng trình thông dịch shell trên PC, chương trình sẽ tính toán (100.100) trong ~ 6s và tính toán (1e4.100) trong ~ 463 giây. Chương trình sẽ có thể tính toán (1e6.100) trong ~ 13-17hrs. Trong trường hợp này tôi sẽ giả sử chương trình đủ điều kiện.

Lưu ý tất cả các lần được làm tròn trong cả phép đo và tính toán.

Perl, 87 85 82 81 byte

Bao gồm +4 cho -pX

Đưa đầu vào trên STDIN dưới dạng một dòng với n trước (lưu ý đây là đảo ngược thứ tự được đề xuất trong thử thách). Vì vậy, để tính toán U(1000000, 100):

unlucky.pl <<< "100 1000000"

Thuật toán dựa trên câu trả lời số may mắn của aditsu Độ phức tạp thời gian là khá nhanh đối với phạm vi yêu cầu. Các trường hợp cho trong 0,7 giây. Do các vấn đề perl có với đệ quy dựa trên, nó sử dụng rất nhiều bộ nhớ. Viết lại nó như là một hàm sẽ làm cho bộ nhớ sử dụng nhưng là một số byte dài hơnO(n^2)100, 10000005333213163do$0O(n)

unlucky.pl:

#!/usr/bin/perl -pX
$_=$a{$_}||=/\d+$/>--$_?2*$&+$^S:($_=$_.A.(do$0,$^S?0|$&+$&/~-$_:$&*$_-1),do$0)

Điều này hoạt động như được hiển thị, nhưng sử dụng bằng chữ ^Sđể có được số điểm yêu cầu.

Tôi không biết về bất kỳ việc sử dụng $^Sperlgolf trước đó .

Trăn 3, 170

from itertools import*
def L(n,k=1):
 if n<2:yield from count(2+k,2)
 t=L(n-1);l=next(t)
 for i in t:
  n+=1
  if(n%l>0)==k:yield i
U=lambda m,n:sum(islice(L(n,0),m-1,m))

Hàm L tạo ra hàng các số may mắn có thể (nếu k là True) hoặc Un (nếu Sai). Đánh giá một cách lười biếng (vì vậy tôi không phải tạo danh sách vô hạn n-1 nếu tôi muốn Un ).

Chạy chức năng U .

Tốc độ

U (1.000.000; 100) mất khoảng 1 giờ 45 phút để chạy trên máy của tôi với PyPy. Tôi nghi ngờ khoảng bốn giờ với CPython. (Vâng, chính xác là 4h 20 phút.)

Nếu tôi sử dụng danh sách thay vì máy phát điện, tôi có thể đạt được một số tốc độ, nhưng tôi sẽ cần một danh sách có kích thước lớn hơn Python cho phép tôi. Và nếu có, nó sẽ cần hàng chục GB RAM.

Có và U (1.000.000; 100) = 5.333.213.163 .

Haskell

Không thể tính toán cho n = 1: 175 160 byte

Khi biên dịch, máy tính của tôi mất 2h 35m để tính toán đầu vào (1000000,100)bằng cách sử dụng này:

n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s) 
l 2=[1,3..]
l m=((l$m-1)!!(m-2))%(l$m-1)
m?n=(((l n)!!(n-1))#(l$n))!!(m-1)

Tôi đã cố gắng loại bỏ where mô-đun, nhưng chúng dường như ảnh hưởng đến tốc độ và tôi không chắc tại sao ... Nhưng tôi nghĩ có nhiều việc cắt tỉa sẽ được thực hiện ở đây.

Phương pháp sử dụng là m?nđể truy vấn câu trả lời đã cho mvàn .

Bị đánh cắp

everynth n xs = y:(everynth n ys) -- Takes every nth element from a list 'xs'
  where y:ys = drop (n-1) xs

skipeverynth n xs = f' n xs $ []  -- Removes every nth element from a list 'xs'
  where f' n xs = (take (n-1) xs ++) . f' n (drop n xs) 

l 2 = [1,3..] -- The base case of the list of lucky numbers for 'n=2'
l m = skipeverynth ((l$m-1)!!(m-2)) (l$m-1) -- Recursively defining next case as being the last one with every 'ath' element skipped. Here, 'a' is the (m-1)th elemnent of the (l (m-1)) list.
ul m = everynth ((l m)!!(m-1)) (l$m) -- This is not used other than to compute the final, required unlucky number list. It picks out every 'ath' element.

ans m n = (ul n)!!(m-1) -- The function giving the answer.

Tôi cho rằng có thể kết hợp các hàm 'Skipeverynth' và 'everynth' thành một hàm duy nhất trả về một cặp.

Tôi đã sử dụng mã loại người này để bỏ qua mọi phần tử thứ n. Tôi đã làm điều đó một vài lần, nhưng nó luôn kém hiệu quả hơn nhiều và tôi không thể hiểu tại sao.

Có thể tính toán cho tất cả n: 170 byte

Điều này về cơ bản là giống nhau, nhưng một vài maxchức năng đã được đưa vào để xử lý trường hợp đặc biệt n=1.

n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s) 
l 1=[1..]
l m=((l$m-1)!!(max 1$m-2))%(l$m-1)
m?n=(((l n)!!(max 1$n-1))#(l$n))!!(m-1)

R 82 byte

f<-function(m,n){a=1:2e8
i=1
while(i<n){a=c(0,a)[c(F,rep(T,i))]
i=i+1}
a[(n+1)*m]}

Sử dụng

f(5,2)
Returns 29

Điều này cần phải có một vectơ đủ lớn để bắt đầu để có đủ số còn lại để trả về giá trị. Vectơ được tạo đã có khoảng 800Mb và hàm có thể xử lý tối đa m = 1e4 và n = 100 nên vẫn còn thiếu mục tiêu.

Để tạo một vectơ đủ lớn để tính f (1e6.100) sẽ cần một vectơ bắt đầu là 1: 2e10. Do quy trình phân bổ dữ liệu R, điều này tạo ra một vectơ> 70Gb không thể chạy trên bất kỳ máy tính nào tôi biết mặc dù mã sẽ chạy.

Error: cannot allocate vector of size 74.5 Gb

Để tham khảo f (1e4.100) chạy trong khoảng 30 giây. Dựa trên điều này và một vài thử nghiệm nhỏ hơn f (1e6.100) sẽ mất khoảng một giờ.

Vợt 332 byte

(λ(N m n)(let loop((l(filter odd?(range 1 N)))(i 1))(define x (list-ref l i))(if(= i (sub1 n))
(begin(set! l(for/list((j(length l))#:when(= 0(modulo(add1 j)x)))(list-ref l j)))(list-ref l(sub1 m)))
(begin(set! l(for/list((j(length l))#:unless(= 0(modulo(add1 j) x)))(list-ref l j)))(if(>= i(sub1 (length l)))l
(loop l(add1 i)))))))

Phiên bản bị đánh cắp:

(define f
  (λ(N m n)
    (let loop ((l (filter odd? (range 1 N))) (i 1))
      (define x (list-ref l i))
      (if (= i (sub1 n))
          (begin (set! l (for/list ((j (length l)) 
                                   #:when (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (list-ref l (sub1 m)))
          (begin (set! l (for/list ((j (length l)) 
                                   #:unless (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (if (>= i (sub1 (length l)))
                     l
                     (loop l (add1 i))))))))

Kiểm tra:

(f 100 5 2)

Đầu ra:

29

Clojure, 221 byte

Mạnh dài nhưng xử lý vụ việc (f 1). Không có trường hợp đặc biệt đó là 183 byte. Đây là quá nhiều nỗ lực để không đăng nó.

(defn f([n](if(< n 2)(take-nth 2(drop 2(range)))(f n 1(take-nth 2(rest(range))))))([n i c](if (< n 2)c(let[N(first(drop i c))F #((if(= 2 n)= >)(mod(inc %)N)0)](f(dec n)(inc i)(filter some?(map-indexed #(if(F %)%2)c)))))))

Đầu ra mẫu:

(pprint (map #(take 10 (f %)) (range 1 10)))
((2 4 6 8 10 12 14 16 18 20)
 (5 11 17 23 29 35 41 47 53 59)
 (19 39 61 81 103 123 145 165 187 207)
 (27 57 91 121 153 183 217 247 279 309)
 (45 97 147 199 253 301 351 403 453 507)
 (55 117 181 243 315 379 441 505 571 633)
 (85 177 277 369 471 567 663 757 853 949)
 (109 225 345 465 589 705 829 945 1063 1185)
 (139 295 447 603 765 913 1075 1227 1377 1537))

1000000 trường hợp 100 đã được tính toán trong khoảng 4,7 giờ, ít nhất là nó đã không sụp đổ.

java -jar target\stackoverflow-0.0.1-SNAPSHOT-standalone.jar 1000000 100
5333213163
"Elapsed time: 1.7227805535565E7 msecs"