知っておくべきこと：

まず、ラッキーナンバー。

ラッキーナンバーは次のように生成されます：

すべての自然数を取る：

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

次に、各2番目の数字を削除します。

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

今、3安全です。

3番目ごとに番号を削除します。

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

今、7安全です。

7番目ごとに番号を削除します。

続けて、すべてのn番目の番号を削除します。ここで、削除n後の最初の安全な番号です。

安全な番号の最後のリストは、ラッキーナンバーです。

不運な数字は、数字の個別のリストで構成されています[U1, U2, U3... Un]。

U1 幸運な「候補者」から削除された最初の数字のセットであるため、次のとおりです。

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

U2 削除される2番目の数値セットです。

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

などなど（U33番目のリスト、U44番目など）

チャレンジ：

あなたのタスクは、2つの入力mとが与えられるとn、mリストのth番目の数を生成しますUn。

入力と出力の例：

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

仕様：

• あなたのプログラムは、m最大で1e6、そしてn最大で動作しなければなりません100。
  • あなたは、両方のことが保証されているmとはn正の整数です。
  • 興味があるなら、U(1e6, 100)= 5,333,213,163。（ありがとう@pacholik！）
• プログラムは、合理的な最新のコンピューターで1日以内にそれを計算する必要があります。

これはcode-golfなので、バイト単位の最短コードが勝ちです！

PS：誰かがこれらを生成するための一般的な公式を思いついたらいいと思います。数式がある場合は、答えに入れてください！

CJam、74バイト

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

オンラインでお試しください！ 大規模な場合はタイムアウトになります。以下の時間の制約について詳しく説明します。

説明：

私たちのプログラムは、aditsuのコードを恥知らずに借りて、N個のラッキーナンバーのリストを生成します。1を2に置き換えると、ふるいの各段階で増分が得られます。残りのコードは、ゼロが見つかるまですべての要素でデクリメントされ（デクリメントされていないテールをスライスして追加する）、シーブのNフェーズの各ステップを一度に効果的にカウントします。

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

タイミング：

絶対に大きな数のプログラムをブラウザーで実行する必要がある場合は、このインタープリターを使用して、プロンプトが表示されたらスクリプトの続行を許可できますが、修飾するには遅すぎる可能性があります。（M、N）=（100,100）を使用するには、約247秒かかります。プログラムの反復はMに関して比較的線形であるため、（1e6,100）の計算には約29日かかります。

PCでシェルインタープリターを使用すると、プログラムは〜6sで（100,100）を計算し、〜463sで（1e4,100）を計算します。プログラムは、（13時間から17時間で）（1e6,100）を計算できるはずです。この場合、プログラムが適格であると想定します。

すべての時間は、測定と計算の両方で切り上げられていることに注意してください。

Perl、87 85 82 81バイト

+4を含む -pX

STDINの入力は、最初にnの1行として入力します（これは、チャレンジで提案された順序の逆です）。計算するにはU(1000000, 100)：

unlucky.pl <<< "100 1000000"

aditsuのラッキーナンバーに基づくアルゴリズムの答え 時間の複雑さのO(n^2)ため、必要な範囲ではかなり高速です。100, 1000000ケースは与え53332131630.7秒に。perlにはdo$0再帰ベースの問題があるため、大量のメモリを使用します。関数として書き換えるとメモリが使用されますO(n)が、バイト数が長くなります

unlucky.pl：

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

これは示されているとおりに機能^Sしますが、リテラルを使用して要求されたスコアを取得します。

$^Sperlgolfでの以前の使用を認識していません。

Python 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))

関数Lは、可能なラッキーナンバー（kがTrueの場合）またはUn（Falseの場合）の行を生成します。遅延評価（したがって、Unが必要な場合はn-1個の無限リストを生成する必要はありません）。

関数Uを実行します。

速度

U（1,000,000; 100）は、PyPyを搭載したマシンで実行するのに約1時間45分かかります。私はCPythonで約4時間を疑います。（はい、正確には4時間20分です。）

ジェネレータの代わりにリストを使用した場合、ある程度の速度が得られるかもしれませんが、Pythonで許可されているよりも大きなサイズのリストが必要になります。もしそうなら、数十ギガバイトのRAMが必要になります。

はい、U（1,000,000; 100）= 5,333,213,163。

ハスケル

n = 1の場合、計算できません：175 160バイト

コンパイルすると、(1000000,100)これを使用する入力を計算するのに私のコンピューターは2時間35分かかりました。

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)

私はwhereモジュールを削除しようとしましたが、速度に影響を与えているようで、その理由はわかりません...しかし、ここでもっと整理する必要があると思います。

使用する方法はm?n、mとを指定して回答を照会するためのものnです。

非ゴルフ

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.

「skipeverynth」関数と「everynth」関数を組み合わせて、ペアを返す単一の関数にすることは可能かもしれません。

この親切な人のコードを使用して、n番目の要素をすべてスキップしました。私は数回自分でそれをしましたが、それは常にはるかに非効率的であり、理由を理解できませんでした。

すべてのnについて計算可能：170バイト

これは基本的に同じですが、maxの特殊なケースを処理するためにいくつかの関数をスローする必要がありました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バイト

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]}

使用法

f(5,2)
Returns 29

これには、値を返すのに十分な数が残っているように、開始するのに十分な大きさのベクトルが必要です。作成されたベクトルはすでに約800Mbであり、関数はm = 1e4およびn = 100まで処理できるため、目標に十分に達しません。

f（1e6,100）を計算するのに十分な大きさのベクトルを作成するには、1：2e10の開始ベクトルが必要です。Rsのデータ割り当て手順により、これにより70Gbを超えるベクトルが作成され、コードは実行されますが、私が知っているどのコンピューターでも実行できません。

Error: cannot allocate vector of size 74.5 Gb

参考までに、f（1e4,100）は約30秒で実行されます。これといくつかの小さなテストf（1e6,100）に基づいて、約1時間かかります。

ラケット332バイト

(λ(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)))))))

ゴルフされていないバージョン：

(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))))))))

テスト：

(f 100 5 2)

出力：

29

Clojure、221バイト

強大ですが、ケースを処理し(f 1)ます。その特別な場合を除いて、183バイトでした。これは、投稿しないようにするための労力が大きすぎました。

(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)))))))

サンプル出力：

(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 100ケースは約4.7時間で計算され、少なくともクラッシュしませんでした。

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