배경

의 모든 주요 요소가 엄격히 초과 하면 숫자 n를 B대략 으로 설명 할 수 있습니다 .nB

도전

두 개의 양의 정수 B와가 주어지면 k처음 k B거친 숫자를 출력하십시오 .

예

하자 f(B, k)첫 번째가 포함 된 세트 반환하는 함수가 될 k B-rough 번호.

> f(1, 10)
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

> f(2, 5)
1, 3, 5, 7, 9

> f(10, 14)
1, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59

하스켈 , 53 44 바이트

b%k=take k[n|n<-[1..],all((>0).mod n)[2..b]]

온라인으로 사용해보십시오!

덕분에 -9 바이트의 H.PWiz 에 합니다!

b%k=                       -- given inputs b and k
 take k                    -- take the first k elements from 
  [n|n<-[1..]              -- the infinite list of all n > 0
   ,all            [2..b]] -- where all numbers from 2 to b (inclusive)
      ((>0).mod n)         -- do not divide n.

파이썬 3 , 80 , 75 바이트

lambda B,k:[i for i in range(1,-~B*k)if all(i%j for j in range(2,B+1))][:k]

온라인으로 사용해보십시오!

5 바이트를 절약 한 shooqie 에게 감사 합니다.

이것은 k 번째의 거친 숫자가 절대 초과하지 않는다고 가정합니다. $B * k$나는 그것을 증명하는 방법을 모르지만 상당히 안전한 가정처럼 보입니다 (그리고 나는 반대의 예를 찾을 수 없습니다).

대체 솔루션 :

파이썬 2 , 78 바이트

B,k=input()
i=1
while k:
 if all(i%j for j in range(2,B+1)):print i;k-=1
 i+=1

온라인으로 사용해보십시오!

이 솔루션은 위의 솔루션을 만들지 않습니다 . 그리고 훨씬 더 효율적입니다.

젤리 , 7 바이트

1Æf>Ạɗ#

온라인으로 사용해보십시오!

펄 6 , 35 32 바이트

nwellnof 덕분에 -3 바이트!

{grep(*%all(2..$^b),1..*)[^$^k]}

온라인으로 사용해보십시오!

두 개의 정수를 사용하고 정수 목록을 반환하는 익명 코드 블록입니다.

설명

{                              }  # Anonymous code block
 grep(             ,1..*)        # Filter from the positive integers
      *              # Is the number
       %             # Not divisible by
        all(      )  # All of the numbers
            2..$^b   # From 2 to b
                         [^$^k]   # And take the first k numbers

Husk, 9 8 bytes

↑foΛ>⁰pN

Try it online!

Takes $B$ as first and $k$ as second input.

↑         -- take the first k elements 
       N  -- from the natural numbers
 f        -- filtered by
  o   p   -- the prime factors
   Λ>⁰    -- are all larger than the first input

숯 , 33 바이트

ＮθＮη≔⁰ζＷ‹Ｌυη«≦⊕ζ¿¬Φθ∧κ¬﹪ζ⊕κ⊞υζ»Ｉυ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＮθＮη

입력 B및 k.

≔⁰ζ

z0으로 설정하십시오 .

Ｗ‹Ｌυη«

우리가 k가치 를 가질 때까지 반복하십시오 .

≦⊕ζ

증분 z.

¿¬Φθ∧κ¬﹪ζ⊕κ

나누기 z에서 모든 숫자에 의한 2에 B어떤 나머지가 0 인 경우와 참조하십시오.

⊞υζ»

그렇지 않은 경우 z사전 정의 된 빈 목록으로 푸시 하십시오.

Ｉυ

목록을 문자열로 캐스트하고 내재적으로 출력하십시오.

자바 스크립트 (ES6), 68 바이트

로 입력을 (b)(k)받습니다.

b=>k=>(o=[],n=1,g=d=>(d<2?o.push(n)==k:n%d&&g(d-1))||g(b,n++))(b)&&o

온라인으로 사용해보십시오!

댓글

b => k => (             // input = b and k
  o = [],               // o[] = output array
  n = 1,                // n = value to test
  g = d => (            // g = recursive function, taking the divisor d
    d < 2 ?             // if d = 1:
      o.push(n) == k    //   push n into o[] and test whether o[] contains k elements
    :                   // else:
      n % d && g(d - 1) //   if d is not a divisor of n, do a recursive call with d - 1
    ) ||                // if the final result of g() is falsy,
    g(b, n++)           // do a recursive call with d = b and n + 1
)(b)                    // initial call to g() with d = b
&& o                    // return o[]

젤리 , 10 바이트

1µg³!¤Ịµ⁴#

온라인으로 사용해보십시오!

작동 원리

1µg³!¤Ịµ⁴#    Dyadic main link. Left = B, right = k
       µ⁴#    Take first k numbers satisfying...
  g             GCD with
   ³!¤          B factorial
      Ị         is insignificant (abs(x) <= 1)?
1µ            ... starting from 1.

자바 스크립트 (Node.js) , 68 바이트

b=>g=(k,i=1,j=b)=>k?j>1?i%j?g(k,i,j-1):g(k,i+1):[i,...g(k-1,i+1)]:[]

온라인으로 사용해보십시오!

APL (NARS), 52 자, 104 바이트

r←a f w;i
r←,i←1⋄→3
i+←1⋄→3×⍳∨/a≥πi⋄r←r,i
→2×⍳w>↑⍴r

위의 'r ← afw; i'다음의 행은 이름이 1 2 3; test입니다.

  o←⎕fmt
  o 1 h 2
┌2───┐
│ 1 2│
└~───┘
  o 1 h 1
┌1─┐
│ 1│
└~─┘
  o 10 h 14
┌14───────────────────────────────────────┐
│ 1 11 13 17 19 23 29 31 37 41 43 47 53 59│
└~────────────────────────────────────────┘

05AB1E , 9 바이트

∞ʒÒ¹›P}²£

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

∞          # Infinite list starting at 1: [1,...]
 ʒ    }    # Filter it by:
  Ò        #  Get all prime factors of the current number
   ¹›      #  Check for each if they are larger than the first input
     P     #  And check if it's truthy for all of them
       ²£  # Leave only the leading amount of items equal to the second input