이야기:

Lucy는 George에게 그의 Lucky Number가 무엇인지 물었습니다. 약간의 숙고 끝에 George는 여러 개의 Lucky Numbers가 있다고 대답했습니다. 약간 혼란스러워 한 루시는 조지에게 첫 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의 경우와 마찬가지로 가장 적은 바이트가 이깁니다.

평소와 같이 표준 허점을 사용한 제출 은 실격 처리됩니다.

파이썬 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. 파이썬 3은 실제로 맵을 평가하지 않기 때문에 파이썬 2가 필요합니다.

첫 번째 루프의 요구는 특수 맡았다 변환을 할 수 r에서 1까지 2로, r+=r<2.

충분히 높은 상한 2**n은 프로그램을 큰 값으로 매우 느리게 만듭니다 n. 사용 n*n+1하면 충분하지만 캐릭터 비용이 듭니다. 참고 n*n작동하지 않습니다 n=1.

하스켈, 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간단히 첫 번째 n를 사용합니다 take 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)

그러나 -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를 삭제하고 ( 이전에 생성 된 숫자를 설명하기 위해 오프셋 됨 ) 누산기를 사용하여 해당 목록으로 반복하는 것입니다 . 에서 , 우리는 홀수로 시작하여 프로세스를 초기화하고 앞쪽으로 압정 하여 운이 좋은 숫자를 얻습니다.nkp(p+1)f31

파이썬 2, 71 69 67

처음에는 이것이 파이썬의 배열 슬라이싱에 큰 도전이 될 것이라고 생각했습니다. 그러나 1 이외의 단계가있는 슬라이스에 동일한 길이의 다른 슬라이스 만 할당 할 수 있음을 발견했을 때 걸림돌이 발생했습니다. 그러나 "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]

Sp3000 덕분에 -2 바이트

> <> , 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까지)와 각각의 이전 운수 l에 대해 역순으로 i를 i / (l-1) 씩 증가시킵니다. l = 1을 제외하고 0 대신 1을 사용하고 추가합니다. 끝에 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";

여기에서 온라인으로 사용해보십시오

파이썬 2, 105101 바이트

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

위의 접근 방식과 비슷하지만 항목이 1 색인이 아닌 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

펄, 86 81 78

86 :

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

업데이트 : 분명히 81 grep{...}보다 낫습니다 map{...?$_:()}.

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

업데이트 : 이제 실제로 하나의 라이너입니다. 멈출 수있어 (?) 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

언 골프 드 :

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 바이트를 단축 할 수 *:와 !목록이 기하 급수적으로 증가하고.

자바 스크립트 (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)

언 골프

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

배쉬 + 코어 유틸리티, 136

나는 이것을 더 아래로 골프하기를 바랐다. 그러나 잘. 쉘 스크립트에서 재귀 함수로 매일 파이프하는 것은 아닙니다.

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
$ 

배쉬 + 코어 유틸리티, 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)
    }
}

체를 만들기 위해 고 루틴과 파이프를 사용하여 직접 구현합니다.

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)