(Diilhami secara acak oleh /mathpro//q/339890 )
(Terkait: 1 , 2 )

Diberikan daftar input dari bilangan prima yang berbeda (misalnya, [2, 5, 7]), dan bilangan bulat n, output semua bilangan bulat positif benar-benar lebih kecil dari nyang hanya berisi bilangan prima sebagai pembagi. Untuk input [2, 5, 7]dan n=15ini berarti output dari [2, 4, 5, 7, 8, 10, 14].

Contoh lebih lanjut

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

Aturan dan Klarifikasi

• Daftar input dijamin tidak kosong, tetapi mungkin hanya elemen tunggal
• Anda dapat menganggap daftar input sudah disortir dengan cara apa pun yang paling nyaman
• n akan selalu lebih besar dari elemen terbesar dalam daftar input
• Karena, misalnya, 2**0 = 1Anda dapat secara opsional memasukkan 1dalam daftar output Anda
• Input dan output dapat diberikan dengan metode apa pun yang mudah
• Anda dapat mencetak hasilnya ke STDOUT atau mengembalikannya sebagai hasil fungsi
• Program lengkap atau fungsi dapat diterima
• Jika berlaku, Anda dapat menganggap bilangan bulat input / output sesuai dengan intrentang asli bahasa Anda
• Celah standar dilarang
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang

Stax , 6 byte

Ç─☼?▬µ

Jalankan dan debug di staxlang.xyz!

Dibongkar (7 byte) dan penjelasan:

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

05AB1E , 6 byte

<LʒfåP

Mengambil bilangan bulat sebagai input pertama, daftar sebagai yang kedua. Termasuk opsional 1dalam output.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Dua alternatif 6 byte yang disediakan oleh @Grimy :

GNfåP–

Cobalah online.

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

Yang ini sangat lambat ( [2,5,7], 15test case sudah habis), tetapi kurang seperti dua pendekatan lainnya:

sиPÑʒ›

Berbeda dengan dua program lain di atas, ia mengambil daftar sebagai input pertama, dan integer sebagai yang kedua. Itu memang termasuk opsional 1dalam output juga.

Cobalah online.

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 byte

Mengambil input sebagai (n)(primes)tempat menetapkan bilangan prima . Keluaran dengan memodifikasi set.

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

Cobalah online!

Berkomentar

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 byte

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]

Cobalah online!

-3 byte terima kasih kepada @xnor

Fungsi ini mengambil urutan utama dan bilangan bulat sebagai input. Outputnya adalah daftar yang mencakup 1.

Tidak Disatukan:

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)

Cobalah online!

Haskell , 51 byte

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]

Cobalah online!

Haskell , 39 byte

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

Cobalah online!

Memeriksa apakah khanya dapat dibagi oleh bilangan prima ldengan melihat apakah produk yang ldibawa ke daya tinggi dapat habis dibagi k.

Python 2 , 65 byte

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

Cobalah online!

Memeriksa apakah khanya dapat dibagi oleh bilangan prima ldengan melihat apakah produk yang ldibawa ke daya tinggi dapat habis dibagi k.

Jika ldapat diambil sebagai daftar string eval("*".join(l)) menghemat 3 byte lebih reduce(int.__mul__,l)dan dapat digunakan dalam Python 3 yang kurang reduce.

Python 3 , 64 byte

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

Cobalah online!

Fungsi mencetak dalam urutan terbalik dan berakhir dengan kesalahan.

Solusi rekursif di bawah ini akan lebih pendek jika nitu sendiri dimasukkan dalam daftar. Saya mencoba menghitung produk secara rekursif ljuga, tapi itu lebih lama.

62 byte (tidak bekerja)

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

Cobalah online!

Gaia , 10 byte

…@e⟪ḍ‡⁻!⟫⁇

Cobalah online!

Saya belum pernah menggunakan ‡monad sebelumnya, ini cukup membantu untuk manipulasi stack.

…		| 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 byte

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

Cobalah online!

Jelly , 7 byte

ṖÆffƑ¥Ƈ

Cobalah online!

Sebuah link diadik yang mengambil batas atas eksklusif sebagai argumen kirinya dan daftar bilangan prima sebagai haknya. Mengembalikan daftar yang mencakup 1 serta angka-angka yang hanya terdiri dari bilangan prima yang disediakan.

Alternatif 7 akan menjadi ṖÆfḟ¥Ðḟ

Python 2 , 98 byte

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

Cobalah online!

Japt -f , 11 8 byte

k
è@e!øV

Cobalah

Japt -f , 7 byte

©k e!øV

Cobalah

Ruby -rprime , 61 byte

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

Cobalah online!

Retina 0.8.2 , 64 byte

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

Cobalah online! Daftar termasuk kasus uji yang lebih kecil ( 10000waktu habis karena semua string panjang). Mengambil input dalam urutan n f1 f2 f3...(faktor tidak perlu menjadi prima tetapi mereka perlu menjadi coprime). Output termasuk 1. Penjelasan:

\d+
$*

Konversikan ke unary.

\G1
$.`,$`;

Buat daftar dari 0 hingga n-1, dalam desimal dan unary.

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

Membagi unary berulang kali dengan faktor apa pun yang tersedia.

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

Keluarkan angka desimal di mana angka unary dikurangi menjadi 1.

Pyth , 10 byte

f!-PThQtUe

Cobalah online!

Mengambil input sebagai [[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 byte

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

Cobalah online!

Port solusi Haskell xnor. Juga menghasilkan 1.

Arang , 22 20 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Terlalu lambat untuk test case yang lebih besar. Penjelasan:

 Φ                      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

Jawaban 22 byte yang lebih cepat sebelumnya:

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Output termasuk 1. Penjelasan:

⊞υ¹

Dorong 1ke daftar kosong yang telah ditentukan.

Ｆυ

Lewati daftar, termasuk item yang didorong ke sana selama loop.

Ｆ×ιθ

Lipat gandakan item saat ini dengan setiap perdana dan lewati produk.

Ｆ›‹κη№υκ

Periksa apakah produk tersebut merupakan nilai baru.

⊞υκ

Jika demikian maka dorong ke daftar.

Ｉυ

Cetak daftar.

C (dentang) , 115 byte

#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];}

Cobalah online!

Solusi berbasis Saringan Eratosthenes.

(Termasuk 1 dalam output)

Berkat saran @ceilingcat: printf (x [i] + "\ 0% d", i ++) alih-alih x [i] && printf ("% d", i), i ++ saya kira itu menggeser penunjuk literal tetapi tidak dapat menemukan dokumentasi, jika ada yang bisa memberi saya wawasan itu akan diterima.