(Випадково надихається /mathpro//q/339890 )
(Пов'язано: 1 , 2 )

З огляду на вхідний перелік чітких простих чисел (наприклад, [2, 5, 7]) та ціле число 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діапазону вашої мови
• Стандартні лазівки заборонені
• Це код-гольф, тому діють усі звичайні правила гольфу, і найкоротший код (у байтах) виграє

Стакс , 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)

Дві альтернативи 6 байтів, надані @Grimy :

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)

JavaScript (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
}                 //

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

Спробуйте в Інтернеті!

-3 байти завдяки @xnor

Функція приймає просту послідовність і ціле 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)

Спробуйте в Інтернеті!

Haskell , 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не ділиться лише праймес l, бачачи, чи добуток lвисокої потужності ділиться на k.

Пітон 2 , 65 байт

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

Спробуйте в Інтернеті!

Перевіряє, чи kне ділиться лише праймес l, побачивши, чи є продуктlвисокої потужності ділиться на k.

Якщо lможна розглядати як список рядків eval("*".join(l)) зберігає 3 байта більш reduce(int.__mul__,l)і може використовуватися в Python 3 , який відчуває нестачуreduce .

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

Спробуйте в Інтернеті!

Гая , 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Ƒ¥Ƈ

Спробуйте в Інтернеті!

Дьядічне посилання, що приймає виключну верхню межу як аргумент зліва, а список прайметів - як праве. Повертає список, що включає 1, а також числа, що складаються лише з доданих праймерів.

Альтернативою 7 було б ṖÆfḟ¥Ðḟ

Python 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
$.`,$`;

Створіть список від 0 до n-1як в десяткових, так і в одинакових.

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

Неодноразово діліть одинар на будь-які наявні фактори.

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

Виведіть десяткові числа, до яких унарне число було зменшено 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)

Perl 6 , 27 байт

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

Спробуйте в Інтернеті!

Порт рішення Haskell від xnor. Також виводить 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: printf (x [i] + "\ 0% d", i ++) замість x [i] && printf ("% d", i), i ++ я вважаю, що це зміщує покажчик прямої, але не Я не знайшов жодної документації, якщо хтось може дати мені деяку інформацію, було б ласкаво.