Câu chuyện:

Lucy hỏi George Số may mắn của anh là gì. Sau khi suy ngẫm, George trả lời rằng anh ta có nhiều số may mắn. Sau một vài nhầm lẫn, Lucy hỏi George nSố may mắn đầu tiên của anh là gì. Sau đó, George yêu cầu bạn, bạn thân của anh ấy, viết cho anh ấy một chương trình để thực hiện công việc cho anh ấy.

Các thách thức:

Bạn sẽ viết một chương trình / hàm sẽ nhận từ đối số đầu vào / hàm chuẩn một chuỗi hoặc số nguyên n. Chương trình / chức năng sau đó sẽ trả về / xuất ra n số Lucky đầu tiên . Con số may mắn được xác định thông qua một cái sàng như sau.

Bắt đầu với các số nguyên dương:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, ...

Bây giờ xóa mọi số thứ hai:

1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, ...

Số thứ hai còn lại là 3 , vì vậy hãy xóa mọi số thứ ba:

1, 3, 7, 9, 13, 15, 19, 21, 25, ...

Bây giờ số còn lại tiếp theo là 7 , vì vậy hãy xóa mọi số thứ bảy:

1, 3, 7, 9, 13, 15, 21, 25, ...

Tiếp theo, loại bỏ mọi số thứ chín và như vậy. Chuỗi kết quả là những con số may mắn.

Chiến thắng:

Như thường lệ đối với codegolf, ít byte nhất sẽ thắng.

Như thường lệ, các bài nộp sử dụng sơ hở tiêu chuẩn bị loại.

Con trăn 2, 79

n=input()
L=range(1,2**n)
for r in L:r+=r<2;map(L.remove,L[r-1::r])
print L[:n]

Phép thuật lặp lại một danh sách khi vòng lặp sửa đổi nó!

Danh sách Lbắt đầu với tất cả các số nguyên 1với giá trị đủ cao. Mã lặp lại qua từng phần tử rcủa L, lấy danh sách con của mọi rphần tử và loại bỏ từng giá trị đó. Kết quả là, các giá trị bị loại bỏ không lặp lại. Cuối cùng, in các nyếu tố đầu tiên .

Biểu thức map(A.remove,B)là một mẹo tôi đã chờ đợi rất lâu để sử dụng. Nó gọi A.removecho từng phần tử của B, điều này làm cho tất cả các phần tử Bbị xóa khỏi A. Có hiệu quả, nó có sự khác biệt danh sách, mặc dù nó đòi hỏi Bphải là một danh sách con của A. Nó yêu cầu Python 2, vì Python 3 sẽ không thực sự đánh giá bản đồ.

Vòng lặp đầu tiên cần được đặc biệt chuyển đổi rtừ 1sang 2, như r+=r<2.

Giới hạn trên đủ cao 2**nlàm cho chương trình rất chậm đối với các giá trị lớn n. Sử dụng n*n+1đủ, nhưng chi phí một nhân vật. Lưu ý rằng n*nkhông làm việc cho n=1.

Haskell, 71 69 byte

s(n:k)p=n:s[m|(i,m)<-zip[p..]k,i`mod`n>0](p+1)
f n=take n$1:s[3,5..]3

Xác định một hàm f. Biểu thức 1:s[3,5..]3ước tính vào danh sách vô số các số may mắn và fchỉ cần lấy số đầu tiên ntrong số chúng take n.

f 20
[1,3,7,9,13,15,21,25,31,33,37,43,49,51,63,67,69,73,75,79]

Tôi có thể cạo 5 byte khỏi sàng bằng cách hiểu danh sách song song

s(n:k)p=n:s[m|m<-k|i<-[p..],i`mod`n>0](p+1)

nhưng điều đó đòi hỏi phải chuyển cờ trình biên dịch khiêm tốn -XParallelListCompcho GHC để cho phép mở rộng.

Giải thích về sàng

s(n:k)p=               -- Sieving a list with head n and tail k with accumulator p is
 n:                    -- the head n, followed by
  s[m|                 -- the result of sieving the list of numbers m
    (i,m)<-zip[p..]k,  -- where (i,m) is drawn from [(p,k_0),(p+1,k_1),(p+2,k_2),..] and
    i`mod`n>0]         -- i does not divide n,
   (p+1)               -- using p+1 as the accumulator

Ý tưởng cơ bản là s(n:k)ptạo ra (p-1)số may mắn thứ n, bỏ mọi nsố thứ tự từ đuôi vô hạn k(bù vào pđể tính các số được tạo trước đó) và đệ quy vào danh sách đó bằng bộ tích lũy (p+1). Trong đó f, chúng tôi khởi tạo quy trình với các số lẻ bắt đầu từ 3và giải 1quyết ở phía trước, thu được chính xác các số may mắn.

Con trăn 2, 71 69 67

Lúc đầu, tôi nghĩ rằng đây sẽ là một thách thức lớn đối với việc cắt mảng của Python. Tuy nhiên, tôi đã gặp phải một vấp ngã khi tôi phát hiện ra rằng các lát có bước khác 1 chỉ có thể có một lát có độ dài giống hệt nhau được gán cho chúng. Nhưng sau khi googling "trăn gỡ lát", niềm tin của tôi đã được khôi phục: Tôi đã tìm thấy một deltuyên bố thú vị thực hiện thủ thuật một cách hoàn hảo.

n=input()
l=range(n*n+9)
for v in l:del l[v&~1::v or 2]
print l[:n]

Phiên bản cũ

n=input()
l=range(1,n*n+9)
for v in l:del l[v-1%v::v+1/v]
print l[:n]

-2 byte nhờ Sp3000.

> <> , 121 114 111 byte

i2+:&:*1\
:})?v:2+>l{
nao2\r~1
)?vv>1+:&:&=?;:[{::nao}]$}l1-[01+}:l3-$%$l1-@@-{$[{~l1
3.\ ff+
!?:<]-1v
~]{43. >

Tôi chỉ có vài từ để nói ...

... "Argh não tôi đau."

Giải trình

> <> là ngôn ngữ lập trình bí truyền 2D và chắc chắn không phù hợp với nhiệm vụ này, do thiếu mảng. Trong thực tế, kiểu dữ liệu duy nhất trong> <> là sự pha trộn kỳ lạ của int / float / char và mọi thứ xảy ra trên một chồng các ngăn xếp.

Đây là danh sách:

Line 1:            i2+:&:*1\

i2+:&              Read a char as input (n) and add 2, copying n+2 into the register
:*                 Duplicate and multiply, giving (n+2)^2 on the stack
1\                 Push 1 and go to the next line

Line 2:            >l{:})?v:2+

l{:})?v            Go to the next line if the stack's length is greater than (n+2)^2
:2+                Otherwise duplicate the top of the stack and add 2 to it

Line 3:            \r~1nao2

r~                 Reverse the stack and pop; stack contains the first (n+2)^2 odd integers
1nao               Print 1 (special case)
2\                 Push 2 (let's call this "i" for "iterations") and go to the next line

Line 4:            >1+:&:&=?;:[{::nao}]$}l1-[01+}:l3-$%$l1-@@-{$[{~l1)?vv

1+                 Increment i
:&:&=?;            If i is equal to n+2 (+2 because we started at 2), halt
:[{::nao}]$}       Print the i-th element down (the next lucky number) and also
                   copy it to the top of the stack, while moving i to the bottom
l1-[               Move everything but i to a new stack
0                  Push 0 (let's call this "r" for recursion depth)

Sieve loop:

1+                 Increment r
}:l3-$%$l1-@@-{$[  Move everything up to the last element to be sieved out to a new stack
{~                 Remove said last element
1)?vv              If the length is 1, go to line 6 (sieving complete)
                   Otherwise go to line 5, which repeats this sieve loop by teleporting

Line 6:            :?!v1-]

:?!v1-]            Keep unrolling and decrementing r until r is 0

Line 7:            >~]{43.             

~]                 Pop r and unroll once more (to the stack where i waits)
43.                Loop, performing everything from line 4 all over again

Đây là một ví dụ giả cho thấy cách thức hoạt động của sàng (đây klà con số may mắn mà chúng tôi sàng):

[[15 13 11 9 7 5 3 1 k=3 r=0]]     -- move -->
[[15 13] [11 9 7 5 3 1 k=3 r=1]]   -- pop  -->
[[15 13] [9 7 5 3 1 k=3 r=1]]      -- move -->
[[15 13] [9 7] [5 3 1 k=3 r=2]]    -- pop  -->
[[15 13] [9 7] [3 1 k=3 r=2]]      -- move -->
[[15 13] [9 7] [3 1] [k=3 r=3]]    -- pop  -->
[[15 13] [9 7] [3 1] [r=3]]        (now we unroll)

CJam - 25

Lri{1$W%{1$\(1e>/+}/)+}/p

Dùng thử trực tuyến

Giải trình:

Việc triển khai này không xóa các số liên tiếp khỏi một mảng, nhưng tính toán từng số dựa trên số lượng sẽ bị xóa trước đó.
Đối với mỗi chỉ số i (từ 0 đến n-1) và mỗi số may mắn trước đó, theo thứ tự ngược lại, chúng tôi tăng i theo i / (l-1), ngoại trừ l = 1, chúng tôi sử dụng 1 thay vì 0 và cũng thêm 1 ở cuối
Ví dụ: với i = 4, chúng ta có 4 số đầu tiên, [1 3 7 9] và tính:
4 + 4 / (9-1) = 4
4 + 4 / (7-1) = 4
4 + 4 / (3 -1) = 6
6 + 6/1 = 12
12 + 1 = 13

L              empty array - the first 0 lucky numbers :)
ri             read and convert to integer (n)
{…}/           for each number (i) from 0 to n-1
    1$         copy the previous array
    W%         reverse the order
    {…}/       for each array element (l)
        1$     copy i
        \(     swap with l and decrement l
        1e>    use 1 if l=1
        /+     divide and add to i
    )+         increment and add the new lucky number to the array
p              pretty print

Pyth: 23 22 byte

<u-G%@GhH+0GQ%2r1^hQ2Q

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Giải trình:

<u-G%@GhH+0GQ%2r1^hQ2Q    Q = input()
             %2r1^hQ2     create the list [1, 2, ..., (Q+1)^2-1][::2]
 u          Q%2r1^hQ2     G = [1, 2, ..., (Q+1)^2-1][::2]
                           modify G for each H in [0, 1, 2, ..., Q]:
  -G%:GhH+0G                  G = G - ([0] + G)[::G[H+1]]
                               (minus is remove in Pyth)
<                    Q    print the first Q elements of the resulting list

Mức giảm thực sự tính toán nhiều hơn Qsố may mắn (lệnh remove được gọi là Q + 1 lần, Q-1 là đủ).

R, 58 byte

n=scan();s=r=1:n^2;for(j in 1:n)r=r[-max(2,r[j])*s];r[1:n]

Với ngắt dòng:

n=scan()              #user input
s=r=1:n^2             #declare r and s simultaneously, both large enough to sieve
for(j in 1:n)
  r=r[-max(2,r[j])*s] #iteratively remove elements by position in vector
r[1:n]                #print

Phiên bản trước, 62 byte

function(n){
  s=r=1:n^2             #declare r and s simultaneously, both large enough to sieve
  for(j in 1:n)
    r=r[-max(2,r[j])*s] #iteratively remove elements by position in vector
  r[1:n]                #print
}

Phiên bản trước, 78 byte

n=as.numeric(readline())   #ask for user input and convert it to numeric
r=1:n^2                    #create a large enough vector to sieve
for(j in 1:n){             #loop
  r=r[-max(2,r[j])*1:n^2]  #iteratively remove elements by position in vector
}
r[1:n]                     #print

CJam, 32 30 byte

3ri:N#,N{0\__I1e>)=%-+}fI(;N<p

Lấy đầu vào từ STDIN.

Mã giải thích :

3ri:N#,                          "Read the input in N and get first 3^N whole numbers";
       N{0\__I1e>)=%-+}fI        "Run the code block N times, storing index in I";
         0\__                    "Put 0 before the array and take 2 copies";
             I1e>)=              "Take min(2, I + 1) th index from the copy";
                   %             "Take every array[ min (2, I + 1)] element from the array";
                    -+           "Remove it from the list and prepend 0 to the list";
                         (;N<p   "Print number index 1 to N";

Dùng thử trực tuyến tại đây

Python 2, 105 101 byte

n=input()
L=range(-1,n*n+9,2)
i=2
while L[i:]:L=sorted(set(L)-set(L[L[i]::L[i]]));i+=1
print L[1:n+1]

Chỉ cần thực hiện đơn giản.

Pyth, 39 36 35 32 byte

J%2r1h^Q2VJI>JhN=J-J%@JhN+2J;<JQ

Tương tự như cách tiếp cận ở trên, nhưng mọi thứ đều được lập chỉ mục 0 thay vì 1 chỉ mục. Hãy thử trực tuyến .

Cảm ơn @Jakube đã chỉ ra một cách tiết kiệm byte.

Toán học, 80 byte

(For[l=Range[#^2];i=1,(m=l[[i++]]~Max~2)<=Length@l,l=l~Drop~{m,-1,m}];l[[;;#]])&

Thực hiện thẳng định nghĩa. Như một số câu trả lời khác, bắt đầu với một phạm vi từ 1đến và sau đó tiếp tục lọc.n2

Perl, 86 81 78

86:

@a=(1..($k=<>)**2);for$n(@a){$i=1;@a=map{$i++%($n+($n<2))?$_:()}@a;$k-=$k&&print"$n "}

CẬP NHẬT: rõ ràng, grep{...}tốt hơn map{...?$_:()} 81:

@a=(1..($k=<>)**2);for$n(@a){$i=1;@a=grep{$i++%($n+($n<2))}@a;$k-=$k&&print"$n "}

CẬP NHẬT: OK, thực sự là một lớp lót bây giờ. Tôi có thể dừng lại. (?) 78:

@a=(1..($k=<>)**2);for$n(@a){$k-=$i=$k&&print"$n ";@a=grep{$i++%($n+=$n<2)}@a}

Tháng Mười, 139 83 72

function r=l(n)r=1:2:n^2;for(i=2:n)h=r(i);r(h:h:end)=[];end;r=r(1:n);end

Ung dung:

function r=l(n)
  r=1:2:n^2;
  for(i=2:n)
    h=r(i);
    r(h:h:end)=[];
  end
r=r(1:n);  # reduce it to only N lucky numbers
end

J, 60 52 byte

   ({.}.@((>:@{.,]#~0<({~{.)|i.@#)@]^:[2,1+2*i.@*:@>:)) 8
1 3 7 9 13 15 21 25

Giải thích (từ phải sang trái):

2,1+2*i.@*:@>:  generates the list 2 1 3 5 7 9... with (n+1)^2 odd numbers
^:[             repeats n times the following
@]                using the list
0<({~{.)|i.@#     is the remainder of the indexes of the lists elements with the first element positive (i.e. index divisible by first element)
]#~               keep those elements from the list
>:@{.,            concatenate a first element with the value of the current one +1
}.@             drop first element
{.              take the first n element

2,1+2*i.@*:@>:dường như quá dài nhưng tôi chỉ có thể rút ngắn nó bằng cách hoán đổi 1 byte *:với !việc làm cho danh sách tăng theo cấp số nhân.

JavaScript (ES6) 96 99

Chỉnh sửa Đếm ngược trong vòng lặp đầu tiên - cảm ơn @DocMax

F=n=>(i=>{
  for(o=[1];--i;)o[i]=i-~i;
  for(;++i<n;)o=o.filter((x,j)=>++j%o[i]);
})(n*n)||o.slice(0,n)

Bị đánh cắp

F=n=>{
  for (i = n*n, o = [1]; --i;)
    o[i] = i+i+1;
  for (; ++i < n; )
    o = o.filter((x, j) => (j+1) % o[i])
  return o.slice(0,n)
}

Kiểm tra trong bảng điều khiển Firefox / FireBug

F(57)

Đầu ra

[1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, 87, 93, 99, 105, 111, 115, 127, 129, 133, 135, 141, 151, 159, 163, 169, 171, 189, 193, 195, 201, 205, 211, 219, 223, 231, 235, 237, 241, 259, 261, 267, 273, 283, 285, 289, 297, 303]

Matlab, 104 byte

function x=f(n)
k=1;N=n;x=0;while nnz(x)<n
x=1:N;m=1;while m-nnz(x)
m=x(x>m);x(m:m:end)=[];end
N=N+2;end

Cảm ơn @flawr vì những bình luận và đề xuất rất phù hợp.

Ví dụ từ dấu nhắc lệnh Matlab:

>> f(40)
ans =
  Columns 1 through 22
     1     3     7     9    13    15    21    25    31    33    37    43    49    51    63    67    69    73    75    79    87    93
  Columns 23 through 40
    99   105   111   115   127   129   133   135   141   151   159   163   169   171   189   193   195   201

Bash + coreutils, 136

Tôi hy vọng chơi golf này nhiều hơn, nhưng tốt. Không phải mỗi ngày bạn chuyển sang một hàm đệ quy trong tập lệnh shell:

f(){
mapfile -tn$2 a
(($1>$2))&&{
tr \  \\n<<<${a[@]}
sed $[${a[-1]}-$2]~${a[-1]}d
}|f $1 $[$2+1]||echo ${a[@]}
}
yes|sed -n 1~2=|f $1 2

Đầu ra:

$ ./lucky.sh 23
1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 87 93 99
$ 

Bash + coreutils, 104

Ngắn hơn bằng cách sử dụng một triển khai đơn giản hơn:

a=(`seq 1 2 $[3+$1**2]`)
for((;i++<$1;));{
a=($(tr \  \\n<<<${a[@]}|sed 0~${a[i]}d))
}
echo ${a[@]:0:$1}

Đi, 326

package main
import"fmt"
func s(k, p int,in chan int)chan int{
    o := make(chan int)
    go func(){
        for p>0{
            o<-<-in;p--
        }
        for{
            <-in
            for i:=1;i<k;i++{o<-<-in}
        }
    }()
    return o
}
func main(){
    n := 20
    fmt.Print(1)
    c := make(chan int)
    go func(c chan int){
        for i:=3;;i+=2{c<-i}
    }(c)
    for i:=1;i<n;i++{
        v := <-c
        fmt.Print(" ", v)
        c = s(v, v-i-2, c)
    }
}

Thực hiện thẳng về phía trước bằng cách sử dụng goroutine và ống để làm sàng.

MATLAB, 62 ký tự

n=input('');o=1:2:n^2;for i=2:n;o(o(i):o(i):end)=[];end;o(1:n)

Tôi đã hiểu sai về thách thức lúc đầu - phiên bản sửa đổi của tôi bây giờ thực sự ngắn hơn.

Vợt 196 byte

Tạo số may mắn tối đa n:

(λ(n)(let loop((l(filter odd?(range 1 n)))(i 1))(define x(list-ref l i))(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)
    (let loop ((l (filter odd? (range 1 n))) (i 1))
      (define x (list-ref l i))
      (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)

Đầu ra:

'(1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 87 93 99)