알아야 할 사항 :

먼저 행운의 숫자.

행운의 숫자는 다음과 같이 생성됩니다.

모든 자연수를 취하십시오.

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

그런 다음 두 번째 숫자를 제거하십시오.

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

이제 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 제거 된 두 번째 숫자 세트입니다.

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

그리고 등등 등등 ( U3세번째리스트, U4네번째 등)

도전:

당신의 작업은 두 개의 입력을 주어 때, m그리고 n의 생성 m목록에 일 수를 Un.

입력 및 출력 예 :

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

명세서:

• 프로그램은 m최대 1e6및 n최대 작동해야합니다 100.
  • 당신은 둘 것을 보장 m하고 n양의 정수입니다.
  • 궁금하다면 U(1e6, 100)= 5,333,213,163. (@pacholik 감사합니다!)
• 귀하의 프로그램은 합리적인 최신 컴퓨터에서 하루 안에이를 계산해야합니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

추신 : 누군가가 이것을 생성하는 일반적인 공식을 생각해 내면 좋을 것입니다. 수식이 있으면 답에 넣으십시오!

CJam , 74 바이트

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

온라인으로 사용해보십시오! 더 큰 경우에는 시간 초과가 발생하며 아래의 시간 제약에 대해서는 더 많은 시간이 소요됩니다.

설명:

우리 프로그램은 아디 츠의 코드 를 부끄럽게 빌려 N 행운의 숫자 목록을 생성하고 1을 2로 대체하면 체의 각 단계마다 증가합니다. 나머지 코드는 0이 발견 될 때까지 (감소되지 않은 꼬리를 자르고 추가하여) 모든 요소에서 감소 하고 한 번에 체의 각 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) 사용에는 ~ 247s가 걸립니다. 프로그램 반복은 M의 관점에서 비교적 선형 적이므로 컴퓨팅 (1e6,100)은 ~ 29 일이 소요될 수 있습니다.

PC에서 쉘 인터프리터를 사용하여 프로그램은 ~ 6 초에서 (100,100)을 계산하고 ~ 463에서 (1e4,100)을 계산합니다. 프로그램은 ~ 13-17 시간 내에 (1e6,100)을 계산할 수 있어야합니다. 이 경우 프로그램이 자격이 있다고 가정합니다.

모든 시간은 측정과 계산에서 모두 반올림되었습니다.

펄, 87 85 82 81 바이트

에 +4 포함 -pX

STDIN에 n을 먼저 입력하여 한 줄로 입력하십시오 (이는 챌린지에서 제안한 순서와 반대입니다). 계산하려면 U(1000000, 100):

unlucky.pl <<< "100 1000000"

를 기반으로 알고리즘 aditsu는 '운이 좋은 수 s에 대답 하는 시간 복잡도는 O(n^2)그것이 필요한 범위 오히려 빠른 그래서. 100, 1000000경우 제공5333213163 0.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에서의 이전 사용을 알지 못합니다.

파이썬 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 (거짓 인 경우)을 생성합니다. 게으르게 평가되었습니다 (따라서 Un 원한다면 n-1 무한 목록 을 생성 할 필요가 없습니다 ).

기능 U를 실행하십시오 .

속도

PyPy로 내 컴퓨터에서 U (1,000,000; 100) 를 실행하는 데 약 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 = e4 및 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

클로저, 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"