(Zufällig inspiriert von /mathpro//q/339890 )
(Verwandte: 1 , 2 )

Bei einer Eingabeliste mit unterschiedlichen Primzahlen (z. B. [2, 5, 7]) und einer Ganzzahl nwerden alle positiven Ganzzahlen ausgegeben, die strikt kleiner sind als diese n, und nur diese Primzahlen als Teiler enthalten. Für die Eingabe [2, 5, 7]und n=15das bedeutet eine Ausgabe von [2, 4, 5, 7, 8, 10, 14].

Weitere Beispiele

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

Regeln und Erläuterungen

• Die Eingabeliste ist garantiert nicht leer, sondern kann nur ein einzelnes Element sein
• Sie können davon ausgehen, dass die Eingabeliste auf die am besten geeignete Weise vorsortiert ist
• n ist immer größer als das größte Element in der Eingabeliste
• Da können Sie zB 2**0 = 1optional 1in Ihre Ausgabeliste aufnehmen
• Die Ein- und Ausgabe kann auf jede bequeme Weise erfolgen
• Sie können das Ergebnis an STDOUT drucken oder als Funktionsergebnis zurückgeben
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig
• Falls zutreffend, können Sie davon ausgehen, dass die Eingabe- / Ausgabe-Ganzzahlen in den systemeigenen intBereich Ihrer Sprache passen
• Standardlücken sind verboten
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt

Stax , 6 Bytes

Ç─☼?▬µ

Führen Sie es aus und debuggen Sie es unter staxlang.xyz!

Entpackt (7 Bytes) und Erklärung:

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

05AB1E , 6 Bytes

<LʒfåP

Übernimmt die Ganzzahl als erste Eingabe, listet als zweite auf. Schließt das wahlweise freigestellte 1in die Ausgabe ein.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Zwei 6- Byte- Alternativen von @Grimy :

GNfåP–

Probieren Sie es online aus.

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

Dieser ist sehr langsam (der [2,5,7], 15Testfall läuft bereits ab), aber weniger wie die beiden anderen Ansätze:

sиPÑʒ›

Im Gegensatz zu den beiden anderen Programmen oben wird die Liste als erste Eingabe und die Ganzzahl als zweite Eingabe verwendet. Es enthält jedoch auch das optionale Element 1in der Ausgabe.

Probieren Sie es online aus.

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 Bytes

Nimmt Eingaben als (n)(primes)wobei Primzahlen eine Menge sind. Ausgänge durch Ändern des Sets.

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

Probieren Sie es online!

Kommentiert

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 Bytes

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]

Probieren Sie es online!

-3 Bytes dank @xnor

Die Funktion verwendet eine Primsequenz und eine Ganzzahl n als Eingaben. Die Ausgabe ist eine Liste, die 1 enthält.

Ungolfed:

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)

Probieren Sie es online!

Haskell , 51 Bytes

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]

Probieren Sie es online!

Haskell , 39 Bytes

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

Probieren Sie es online!

Prüft, ob knur durch Primzahlen teilbar ist, indem geprüft lwird, ob das lauf eine hohe Potenz gebrachte Produkt durch geteilt werden kann k.

Python 2 , 65 Bytes

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

Probieren Sie es online!

Prüft, ob knur durch Primzahlen teilbar ist, indem geprüft lwird, ob das lauf eine hohe Potenz gebrachte Produkt durch geteilt werden kann k.

Wenn lals eine Liste von Strings genommen werden eval("*".join(l)) spart 3 Bytes über reduce(int.__mul__,l)und kann in Python 3 verwendet werden , die fehlt reduce.

Python 3 , 64 Bytes

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

Probieren Sie es online!

Eine Funktion die in umgekehrter Reihenfolge druckt und mit Fehler beendet.

Die unten stehende rekursive Lösung wäre kürzer, wenn sie nselbst in die Liste aufgenommen würde. Ich habe auch versucht, das Produkt rekursiv zu berechnen l, aber das war länger.

62 Bytes (nicht funktionsfähig)

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

Probieren Sie es online!

Gaia , 10 Bytes

…@e⟪ḍ‡⁻!⟫⁇

Probieren Sie es online!

Ich habe noch nie ‡mit einer Monade gearbeitet, sie ist sehr hilfreich für die Stapelmanipulation.

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

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

Probieren Sie es online!

Gelee , 7 Bytes

ṖÆffƑ¥Ƈ

Probieren Sie es online!

Eine dyadische Verknüpfung, bei der die exklusive obere Schranke als linkes Argument und die Liste der Primzahlen als rechtes Argument verwendet wird. Gibt eine Liste zurück, die 1 sowie die Zahlen enthält, die nur aus den angegebenen Primzahlen bestehen.

Eine Alternative wäre 7 ṖÆfḟ¥Ðḟ

Python 2 , 98 Bytes

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

Probieren Sie es online!

Japt -f , 11 8 Bytes

k
è@e!øV

Versuch es

Japt -f , 7 Bytes

©k e!øV

Versuch es

Ruby -rprime , 61 Bytes

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

Probieren Sie es online!

Retina 0.8.2 , 64 Bytes

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

Probieren Sie es online! Die Liste enthält kleinere Testfälle ( 10000Timeout wegen der langen Zeichenfolgen). Nimmt Eingaben in die Reihenfolge vor n f1 f2 f3...(Faktoren müssen nicht prim sein, müssen aber coprime sein). Ausgabe enthält1 . Erläuterung:

\d+
$*

In Unary konvertieren.

\G1
$.`,$`;

Generieren Sie eine Liste von 0 bis n-1, sowohl dezimal als auch unär.

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

Teilen Sie das Unäre wiederholt durch alle verfügbaren Faktoren.

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

Geben Sie die Dezimalzahlen aus, auf die die unäre Zahl reduziert wurde 1.

Pyth , 10 Bytes

f!-PThQtUe

Probieren Sie es online!

Übernimmt die Eingabe als [[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 Bytes

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

Probieren Sie es online!

Port von xnors Haskell-Lösung. Gibt auch 1 aus.

Holzkohle , 22 bis 20 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Zu langsam für den größeren Testfall. Erläuterung:

 Φ                      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

Vorherige schnellere 22-Byte-Antwort:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ausgabe enthält 1. Erläuterung:

⊞υ¹

Drücken Sie 1auf die vordefinierte leere Liste.

Ｆυ

Durchlaufen Sie die Liste einschließlich aller Elemente, die während der Schleife an sie gesendet wurden.

Ｆ×ιθ

Multiplizieren Sie den aktuellen Gegenstand mit jedem Prim und ziehen Sie die Schleife über die Produkte.

Ｆ›‹κη№υκ

Überprüfen Sie, ob das Produkt ein neuer Wert ist.

⊞υκ

Wenn ja, dann schieben Sie es auf die Liste.

Ｉυ

Liste drucken.

C (clang) , 115 Bytes

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

Probieren Sie es online!

Ein Sieb auf Eratosthenes-Basis.

(Enthält 1 in der Ausgabe)

Dank @ceilingcat Vorschlag: printf (x [i] + "\ 0% d", i ++) anstelle von x [i] && printf ("% d", i), i ++ Ich nehme an, es verschiebt den Zeiger des Literales, aber nicht Keine Dokumentation gefunden, wenn mir jemand einen Einblick geben kann, wäre es willkommen.