( /mathpro//q/339890에서 무작위로 영감을 얻음 )
(관련 : 1 , 2 )

고유 한 소수 (예 :)의 입력 목록 [2, 5, 7]과 integer가 주어지면 소수 n보다 작은 n소수만 포함하는 모든 양의 정수를 엄격하게 출력합니다 . 입력 [2, 5, 7]및 n=15이것의 출력을 의미한다 [2, 4, 5, 7, 8, 10, 14].

추가 예

[list] n | output

[2, 5, 7] 15 | [2, 4, 5, 7, 8, 10, 14]
[2, 5, 7] 14 | [2, 4, 5, 7, 8, 10]
[2] 3 | [2]
[2] 9 | [2, 4, 8]
[103, 101, 97] 10000 | [97, 101, 103, 9409, 9797, 9991]
[97, 101, 103] 104 | [97, 101, 103]

규칙 및 설명

• 입력 목록은 비어 있지 않지만 단일 요소 일 수 있습니다.
• 가장 편리한 방법으로 입력 목록이 미리 정렬되어 있다고 가정 할 수 있습니다
• n 입력 목록에서 항상 가장 큰 요소보다 큽니다.
• 예를 들어, 2**0 = 1선택적으로 1출력 목록에 포함시킬 수 있습니다.
• 편리한 방법으로 입력 및 출력 가능
• 결과를 STDOUT에 인쇄하거나 함수 결과로 리턴 할 수 있습니다.
• 전체 프로그램 또는 기능이 허용됩니다
• 해당되는 경우 입력 / 출력 정수가 언어의 기본 int범위에 맞는 것으로 가정 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

Stax , 6 바이트

Ç─☼?▬µ

staxlang.xyz에서 실행하고 디버그하십시오!

압축 해제 (7 바이트) 및 설명 :

vf:Fn-!
vf         Filter range [1..n-1]:
  :F         Distinct prime factors
    n-       Remove all in provided list
      !      Is empty?

05AB1E , 6 바이트

<LʒfåP

정수를 첫 번째 입력으로 취하고 두 번째로 나열하십시오. 1출력에 옵션 을 포함합니다 .

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

설명:

<       # Decrease the (implicit) input by 1
 L      # Create a list in the range [1,input-1]
  ʒ     # Filter it by:
   f    #  Get all prime factors of the current number (without duplicates)
    å   #  Check for each if its in the (implicit) input-list
     P  #  And check if this is truthy for all
        # (after the filter, the result is output implicitly)

@Grimy가 제공하는 두 개의 6 바이트 대안 :

GNfåP–

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

G       # Loop `N` in the range [1, (implicit) input):
 Nf     #  Get all prime factors of `N` (without duplicates)
   å    #  Check for each if its in the (implicit) input-list
    P   #  And check if this is truthy for all
     –  #  If it is, output the current `N` with trailing newline

이것은 매우 느리지 만 ( [2,5,7], 15테스트 케이스는 이미 시간 초과됩니다), 다른 두 가지 접근 방식보다 적습니다.

sиPÑʒ›

위의 다른 두 프로그램과 달리 목록은 첫 번째 입력으로, 정수는 두 번째로 사용합니다. 그러나 1출력에 옵션도 포함됩니다 .

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

s       # Swap so the stack is now [list-input, integer-input]
 и      # Repeat the list (flattened) the integer amount of times
        #  i.e. [2,5] and 10 → [2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5]
  P     # Take the product of this list
        #  → 10000000000
   Ñ    # Get all divisors of this integer
        # (the bottleneck for larger integers in this approach)
        #  → [1,2,4,5,8,10,16,20,25,32,40,50,64,80,100,125,128,160,200,250,256,320,400,500,512,625,640,800,1000,1024,1250,1280,1600,2000,2500,2560,3125,3200,4000,5000,5120,6250,6400,8000,10000,12500,12800,15625,16000,20000,25000,25600,31250,32000,40000,50000,62500,64000,78125,80000,100000,125000,128000,156250,160000,200000,250000,312500,320000,390625,400000,500000,625000,640000,781250,800000,1000000,1250000,1562500,1600000,1953125,2000000,2500000,3125000,3200000,3906250,4000000,5000000,6250000,7812500,8000000,9765625,10000000,12500000,15625000,16000000,19531250,20000000,25000000,31250000,39062500,40000000,50000000,62500000,78125000,80000000,100000000,125000000,156250000,200000000,250000000,312500000,400000000,500000000,625000000,1000000000,1250000000,2000000000,2500000000,5000000000,10000000000]
    ʒ   # Filter these divisors:
     ›  #  And only keep those where the (implicit) input-integer is larger than the divisor
        #  → [1,2,4,5,8]
        # (after the filter, the result is output implicitly)

자바 스크립트 (ES6),  64 ... 52  50 바이트

입력으로서 취하고 (n)(primes)여기서 , 소수 가 설정된 받습니다. 세트를 수정하여 출력합니다.

n=>g=(s,q=1)=>{for(p of s)(p*=q)<n&&g(s.add(p),p)}

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

댓글

n =>              // n = maximum value
g = (             // g is a recursive function taking:
  s,              //   s = set of primes
  q = 1           //   q = current product, initialized to 1
) => {            //
  for(p of s)     // for each value p in s:
    (p *= q)      //   multiply p by q
    < n &&        //   if the result is less than n:
      g(          //     do a recursive call:
        s.add(p), //       with p added to the set
        p         //       with q = p
      )           //     end of recursive call
}                 //

파이썬 3 , 68 65 바이트

f=lambda s,n,c=1:n//c*s and f(s,n,s[0]*c)+f(s[1:],n,c)or[c][:c<n]

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

@xnor 덕분에 -3 바이트

이 함수는 소수 시퀀스와 정수 n을 입력으로받습니다. 출력은 1을 포함하는 목록입니다.

언 골프 드 :

def f(s, n, c=1):
    if not c < n:
       return []
    elif not s:
       return [c]
    else:
       return f(s,n,s[0]*c) + f(s[1:],n,c)

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

하스켈 , 51 바이트

xpmapM((<$>[0..n]).(^))p$1,x,x^2,\ldots,x^n$$n$ 은 상한으로 사용 된 두 번째 입력)을 계산 한 다음 모든 시퀀스의 직교 곱을 계산합니다. 그 후 우리는product 다음이 데카르트 제품의 모든 항목을 너무 큰 항목을 모두 필터링합니다.

np$(\#p)^n$

p#n=[k|k<-product<$>mapM((<$>[0..n]).(^))p,k<n,k>1]

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

하스켈 , 39 바이트

l%n=[k|k<-[2..n-1],mod(product l^k)k<1]

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

고출력 으로 가져온 제품 k이로 나눌 수 있는지 확인 하여 소수만 소수로 나눌 수 있는지 확인합니다 .llk

파이썬 2 , 65 바이트

lambda l,n:[k for k in range(2,n)if reduce(int.__mul__,l)**n%k<1]

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

고출력 으로 가져온 제품 k이로 나눌 수 있는지 확인 하여 소수만 소수로 나눌 수 있는지 확인합니다 .llk

l문자열 목록으로 가져올 수 있다면 eval("*".join(l)) 3 바이트 를 절약reduce(int.__mul__,l) 하고 파이썬 3에서 사용할 수 있습니다 reduce.

파이썬 3 , 64 바이트

def f(l,n,P=1):
 for x in l:P*=x
 n-=1;P**n%n or print(n);f(l,n)

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

기능이 역순으로 인쇄되고 오류와 함께 종료됩니다.

아래의 재귀 솔루션은 다음과 같은 경우 더 짧습니다. n 은 목록에 포함되어 . 나는 제품을 재귀 적으로 계산하려고 시도했지만 l더 길었다.

62 바이트 (작동하지 않음)

f=lambda l,n:n*[f]and[n][reduce(int.__mul__,l)**n%n:]+f(l,n-1)

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

Gaia , 10 바이트

…@e⟪ḍ‡⁻!⟫⁇

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

‡전에는 모나드와 함께 사용해 본 적이 없으며 스택 조작에 매우 유용합니다.

…		| push [0..n-1]
@e		| push list of primes
  ⟪    ⟫⁇	| filter [0..n-1] for where the following predicate is true:
   ḍ‡		| the list of prime factors
     ⁻		| minus the list of primes
      !		| is empty

J , 24 바이트

(]#~0=1#.(-."1~q:))2}.i.

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

젤리 , 7 바이트

ṖÆffƑ¥Ƈ

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

배타적 인 상한을 왼쪽 인수로 사용하고 소수 목록을 오른쪽으로 사용하는 2 진 링크. 제공된 소수로 구성된 숫자뿐만 아니라 1을 포함하는 목록을 반환합니다.

대안 7은 ṖÆfḟ¥Ðḟ

파이썬 2 , 98 바이트

lambda a,n:[i for i in R(2,n)if{p for p in R(2,i+1)if(i%p<1)*all(j%p for j in R(2,p))}<=a]
R=range

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

Japt -f , 11 8 바이트

k
è@e!øV

시도 해봐

Japt -f , 7 바이트

©k e!øV

시도 해봐

루비 -rprime , 61 바이트

->n,l{(2..n).select{|i|i.prime_division.all?{|b,|[b]-l==[]}}}

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

레티 나 0.8.2 , 64 바이트

\d+
$*
\G1
$.`,$`;
+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*
!`\d+(?=,1;)

온라인으로 사용해보십시오! 목록에 작은 테스트 사례가 포함됩니다 ( 10000모든 긴 문자열로 인해 시간이 초과 됨). 순서대로 입력을 n f1 f2 f3...받습니다 (요소는 소수 일 필요는 없지만 동시성이어야 함). 출력에 포함됩니다 1. 설명:

\d+
$*

단항으로 변환합니다.

\G1
$.`,$`;

n-110 진수와 단항 모두 에서 0에서까지의 목록을 생성하십시오 .

+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*

사용 가능한 요인으로 단항을 반복해서 나눕니다.

!`\d+(?=,1;)

단수가 감소 된 10 진수를 출력합니다 1.

Pyth , 10 바이트

f!-PThQtUe

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

다음과 같이 입력을받습니다. [[primes...], n]

        Ue  # range(0, Q[-1])  (Q is the input, implicit)
       t    #                [1:] -> range(1, Q[-1]), tUe == PSe
f           # filter that on the condition: lambda T:
   PT       # prime_divisors(T)
  -  hQ     #                   - Q[0]
 !          # logical negation (![] == True)

펄 6 , 27 바이트

{grep [*](@^a)**$^b%%*,^$b}

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

xnor의 Haskell 솔루션 포트. 또한 1을 출력합니다.

숯 , 22 20 바이트

ＩΦ…²η⬤…·²ι∨﹪ιλ⊙θ¬﹪λν

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 더 큰 테스트 사례에서는 너무 느립니다. 설명:

 Φ                      Filter on
  …                     Range from
   ²                    Literal `2` to
    η                   Input limit
     ⬤                  Where all values
      …·                Inclusive range from
        ²               Literal `2` to
         ι              Filter value
          ∨             Either
             λ          Inner value
           ﹪            Is not a divisor of
            ι           Filter value
              ⊙         Or any of
               θ        Input primes
                   ν    Current prime
                ¬﹪      Is a divisor of
                  λ     Inner value
Ｉ                       Cast to string for implicit print

이전의 더 빠른 22 바이트 답변 :

⊞υ¹ＦυＦ×ιθＦ›‹κη№υκ⊞υκＩυ

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

⊞υ¹

1사전 정의 된 빈 목록으로 푸시 하십시오.

Ｆυ

루프 중에 푸시 된 항목을 포함하여 목록을 반복합니다.

Ｆ×ιθ

현재 항목에 각 소수를 곱하고 제품을 반복합니다.

Ｆ›‹κη№υκ

제품이 새로운 가치인지 확인하십시오.

⊞υκ

그렇다면 목록으로 밉니다.

Ｉυ

목록을 인쇄하십시오.

C (클랑) , 115 바이트

#define f(n,l,z){int j,i,k,x[n]={};for(i=x[1]=1;i<n;printf(x[i]+"\0%d ",i++))for(j=z;j--;k<n?x[k]=x[i]:0)k=i*l[j];}

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

에라토스테네스의 체 기반 솔루션.

(출력에 1 포함)

@ ceilingcat 제안 덕택 : x [i] && printf ( "% d", i) 대신 printf (x [i] + "\ 0 % d", i ++), i ++ 리터럴 포인터를 이동한다고 가정했지만 아무도 나에게 통찰력을 줄 수 있다면 어떤 문서도 찾을 수 없다면 환영받을 것입니다.