เรื่อง:

ลูซี่ถามจอร์จว่าหมายเลขนำโชคของเขาคืออะไร หลังจากใคร่ครวญจอร์จตอบว่าเขามีเลขนำโชคหลายตัว หลังจากเกิดความสับสนnเล็กน้อยลูซี่ถามจอร์จว่าหมายเลขนำโชคแรกของเขาคืออะไร จอร์จจึงขอให้คุณเพื่อนของเขาเขียนโปรแกรมเพื่อทำงานให้เขา

ความท้าทาย:

คุณจะเขียนโปรแกรม / ฟังก์ชั่นที่จะได้รับจากการโต้แย้งอินพุต / nฟังก์ชั่นมาตรฐานสตริงหรือจำนวนเต็ม โปรแกรม / ฟังก์ชั่นจะส่งกลับ / ส่งออกn Lucky Numbersแรก หมายเลขนำโชคถูกกำหนดผ่านตะแกรงดังนี้

เริ่มต้นด้วยจำนวนเต็มบวก:

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, ...

ตอนนี้ลบทุกหมายเลขที่สอง:

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

จำนวนที่เหลือที่สองคือ3ดังนั้นลบทุก ๆ สามหมายเลข:

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

ตอนนี้จำนวนที่เหลืออยู่ถัดไปคือ7ดังนั้นลบทุก ๆ หมายเลขที่เจ็ด:

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

ถัดไปลบทุกหมายเลขที่เก้าและอื่น ๆ ลำดับที่ได้คือหมายเลขนำโชค

ชนะ:

ตามปกติสำหรับ codegolf ไบต์ที่น้อยที่สุดจะชนะ

ตามปกติการส่งโดยใช้ช่องโหว่มาตรฐานจะถูกตัดสิทธิ์

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

ความมหัศจรรย์ของการวนซ้ำรายการขณะที่ลูปแก้ไขมัน!

รายการLเริ่มต้นด้วยจำนวนเต็มทั้งหมด1เป็นค่าที่สูงพอสมควร รหัสจะวนซ้ำไปตามแต่ละองค์ประกอบrของLการรับรายการย่อยของทุกrองค์ประกอบและลบค่าเหล่านั้นออก ดังนั้นค่าที่ลบออกจะไม่ซ้ำไปซ้ำมา ในตอนท้ายพิมพ์nองค์ประกอบแรก

การแสดงออกmap(A.remove,B)เป็นเคล็ดลับที่ฉันรอมานานแล้วที่จะใช้ มันเรียกร้องA.removeสำหรับองค์ประกอบแต่ละBซึ่งเป็นสาเหตุขององค์ประกอบทั้งหมดของการลบออกจากB Aได้อย่างมีประสิทธิภาพก็จะใช้เวลาแตกต่างรายการแม้ว่ามันจะต้องใช้ให้เป็นรายการย่อยของB Aมันต้องใช้ Python 2 เนื่องจาก Python 3 ไม่สามารถประเมินแผนที่ได้

วงแรกที่จะต้องพิเศษดาดการแปลงrจาก1การเป็น2r+=r<2

พอสูงผูกไว้บนของทำให้โปรแกรมช้ามากสำหรับค่ามาก2**n nใช้n*n+1พอเพียง แต่ใช้อักขระ โปรดทราบว่าไม่ทำงานสำหรับn*nn=1

Haskell, 71 69 ไบต์

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

fกำหนดฟังก์ชั่น การแสดงออก1:s[3,5..]3ประเมินไปยังรายการที่ไม่มีที่สิ้นสุดของหมายเลขโชคดีและfใช้เวลาเพียงแค่ครั้งแรกของพวกเขาโดยntake n

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

ฉันสามารถโกน 5 ไบต์ออกจากตะแกรงโดยใช้รายการคู่ขนาน

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

แต่นั่นจะต้องผ่านการตั้งค่าสถานะคอมไพเลอร์ humongous -XParallelListCompเพื่อ GHC เพื่อเปิดใช้งานส่วนขยาย

คำอธิบายของตะแกรง

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

แนวคิดพื้นฐานคือการs(n:k)pสร้าง(p-1)หมายเลขนำโชคnให้ลดลงทุกnเลข th จากส่วนท้ายไม่มีที่สิ้นสุดk(ชดเชยด้วยpไปยังหมายเลขที่สร้างขึ้นก่อนหน้านี้) และวนซ้ำไปยังรายการนั้นด้วยแอคคูมูเล(p+1)เตอร์ ในfเราเริ่มต้นกระบวนการด้วยตัวเลขคี่ที่เริ่มต้นจาก3และ1ไปข้างหน้ารับตัวเลขที่โชคดี

Python 2, 71 69 67

ตอนแรกฉันคิดว่านี่จะเป็นความท้าทายที่ยิ่งใหญ่สำหรับการแบ่งส่วนข้อมูลของไพ ธ อน อย่างไรก็ตามฉันพบบล็อกสะดุดเมื่อฉันค้นพบชิ้นส่วนที่มีขั้นตอนอื่นที่ไม่ใช่ 1 สามารถมีความยาวเท่ากันอีกชิ้นที่กำหนดให้พวกเขาเท่านั้น แต่หลังจาก googling "python remove slice" ความเชื่อของฉันได้รับการฟื้นฟู: ฉันพบdelคำสั่งที่ขี้ขลาดที่ใช้เล่ห์เหลี่ยมอย่างสมบูรณ์แบบ

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

เวอร์ชั่นเก่า

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

-2 ไบต์ขอบคุณ Sp3000

> <> , 121 114 111 ไบต์

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

ฉันมีเพียงไม่กี่คำที่จะพูด ...

... "สมองข้าเจ็บปวดแล้ว"

คำอธิบาย

> <> เป็นภาษาเขียนโปรแกรม 2D ที่ลึกลับและไม่เหมาะกับงานนี้อย่างแน่นอนเนื่องจากไม่มีอาเรย์ ในความเป็นจริงชนิดข้อมูลเดียวใน> <> เป็นการผสมผสานที่แปลกประหลาดของ int / float / char และทุกอย่างเกิดขึ้นในกองสแต็ค

นี่คือบทสรุป:

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

นี่คือตัวอย่างการเยาะเย้ยที่แสดงให้เห็นอย่างคร่าวๆว่าการทำงานของร่อน (นี่kคือเลขนำโชคที่เรากรองด้วย):

[[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

ลองออนไลน์

คำอธิบาย:

การใช้งานนี้ไม่ได้ลบตัวเลขออกจากอาร์เรย์อย่างต่อเนื่อง แต่จะคำนวณแต่ละตัวเลขตามจำนวนที่จะถูกลบไปก่อนหน้า
สำหรับแต่ละดัชนี i (จาก 0 ถึง n-1) และเลขนำโชคก่อนหน้านี้แต่ละตัวในลำดับย้อนกลับเราเพิ่ม i ด้วย i / (l-1) ยกเว้น l = 1 เราใช้ 1 แทน 0 และเพิ่ม 1 ในตอนท้าย
เช่นสำหรับ i = 4 เรามีตัวเลข 4 ตัวแรกคือ [1 3 7 9] และคำนวณ:
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 ไบต์

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

ลองใช้งานออนไลน์: Pyth Compiler / Executor

คำอธิบาย:

<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

การลดจริงคำนวณมากกว่าQเลขนำโชค (คำสั่งลบเรียกว่า Q + 1 ครั้ง, Q-1 น่าจะเพียงพอ)

R, 58 ไบต์

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

ด้วยตัวแบ่งบรรทัด:

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

รุ่นก่อนหน้า 62 ไบต์

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
}

รุ่นก่อนหน้า 78 ไบต์

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 ไบต์

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

รับอินพุตจาก STDIN

คำอธิบายรหัส :

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";

ลองออนไลน์ได้ที่นี่

Python 2 105 101 ไบต์

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]

เพียงแค่การใช้งานที่ตรงไปตรงมา

Pyth, 39 36 35 32 ไบต์

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

คล้ายกับวิธีการข้างต้น แต่สิ่งต่าง ๆ มีดัชนี 0 มากกว่าดัชนี ลองมันออนไลน์

ขอบคุณ @Jakube สำหรับการชี้ให้เห็นการประหยัดไบต์

Mathematica, 80 ไบต์

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

การนำไปปฏิบัติของคำจำกัดความ เช่นเดียวกับคำตอบอื่น ๆ ให้เริ่มด้วยช่วงจาก1ถึงแล้วทำการกรอง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 "}

UPDATE: ชัดgrep{...}กว่าmap{...?$_:()} 81:

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

UPDATE: โอเคจริงๆแล้วเป็นซับเดี่ยว ฉันหยุดได้ (?) 78:

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

คู่, 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

Ungolfed:

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 ไบต์

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

คำอธิบาย (จากขวาไปซ้าย):

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.@*:@>:ดูเหมือนว่าทางยาวเกินไป แต่ฉันเท่านั้นที่สามารถลดได้โดย 1 ไบต์แลก*:กับ!การทำรายการเติบโตชี้แจง

JavaScript (ES6) 96 99

แก้ไขการนับถอยหลังในวงแรก - ขอบคุณ @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)

Ungolfed

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

ทดสอบในคอนโซล Firefox / FireBug

F(57)

เอาท์พุต

[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 ไบต์

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

ด้วยขอบคุณ @flawr สำหรับความคิดเห็นและข้อเสนอแนะที่เหมาะสมมาก

ตัวอย่างจากพรอมต์คำสั่ง 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

ฉันหวังว่าจะได้เล่นกอล์ฟนี้มากกว่านี้ แต่ก็ดี ไม่ใช่ทุกวันที่คุณไพพ์ไปยังฟังก์ชัน recursive ในเชลล์สคริปต์:

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

เอาท์พุท:

$ ./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

ตัวย่อใช้การติดตั้งที่ตรงไปตรงมามากขึ้น:

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

ไปที่ 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)
    }
}

การนำไปใช้งานตรงไปตรงมาโดยใช้ goroutine และท่อเพื่อทำตะแกรงร่อน

MATLAB, 62 ตัวอักษร

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

ฉันตีความความท้าทายในตอนแรกผิด - เวอร์ชันที่แก้ไขของฉันตอนนี้สั้นลงจริง ๆ

แร็กเก็ต 196 ไบต์

สร้างหมายเลขนำโชคเกิน 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)))))

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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

การทดสอบ:

(f 100)

เอาท์พุท:

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