Au moment de la soumission au bac à sable, j'avais 17017 points de réputation, que vous pourrez tous factoriser en 7 × 11 × 13 × 17, un produit de 4 nombres premiers consécutifs.

Veuillez écrire une fonction ou un programme pour sortir tous les produits de deux nombres premiers consécutifs ou plus jusqu'à un entier d'entrée n. Par exemple, étant donné que n=143vous devez produire 6, 15, 30, 35, 77, 105, 143(ou un format de sortie équivalent).

Des restrictions normales sur les E / S et les failles s'appliquent.

C'est le code-golf , donc le programme le plus court l'emporte.

Gelée , 14 10 octets

(sans aucun doute il y a du golf à faire ici! - yep ...)
-4 octets grâce à @Dennis - remplacez le chèque pour plus grand que n en utilisant une plage

ÆRẆP€ḟÆRfR

Remarque - ceci est à la fois extrêmement inefficace et les résultats ne sont pas triés.

Testez-le sur TryItOnline

Comment?

ÆRẆP€ḟÆRfR - main link takes an argument, n
ÆR    ÆR   - primes up to n
  Ẇ        - all sublists
   P€      - product for each
     ḟ     - filter out the primes (since the sublists include those of lnegth 1)
        fR - filter out any not in range [1,N]
             (yep, it's calculating all products of primes up to n - gross)

MATL , 25 20 octets

Zq&Xf"@gnq?2MpG>~?6M

Approche similaire à celle de la réponse de Jonathan Allan .

Essayez-le en ligne!

Ancienne version, 25 octets

:YF!"@2<@sq0@0hhdz2=v?X@D

Ceci obtient les exposants de la décomposition en facteurs premiers pour tous les nombres de 1à l'entrée. Pour chacun, il vérifie:

1. Si tous les exposants sont inférieurs à 2.
2. Si la somme de tous les exposants est supérieure à 1.
3. Le tableau d'exposants est étendu avec un zéro supplémentaire à chaque extrémité. Les différences consécutives du tableau étendu sont calculées. Il devrait y avoir exactement 2 différences non nulles.

Si les trois conditions sont remplies, le nombre s'affiche. Les résultats sont en ordre croissant.

Javascript (ES6), 105 104 bytes

n=>{for(i=1,P=[];i++<n;P[P.every(v=>i%v)?i:n]=i);P.map(i=>P.map(j=>j>i&&(p*=j)<=n&&console.log(p),p=i))}

Démo

var f =
n=>{for(i=1,P=[];i++<n;P[P.every(v=>i%v)?i:n]=i);P.map(i=>P.map(j=>j>i&&(p*=j)<=n&&console.log(p),p=i))}

f(143)

05AB1E , 17 15 octets

L<ØŒ€PD¹>‹ÏDp_Ï

Explication

L<Ø                 # get the first N primes, where N is the input
   Π               # get all combinations of consecutive primes
    €P              # calculate the product of these sublists
      D¹>‹Ï         # keep only the products less than or equal to N
           Dp_Ï     # keep only those that aren't prime

Essayez-le en ligne!

Pyth, 18 octets

f}PTftlY.:fP_YSQ)S

Un programme qui prend l'entrée d'un entier sur STDIN et imprime une liste d'entiers.

Essayez-le en ligne

Comment ça fonctionne

f}PTftlY.:fP_YSQ)S  Program. Input: Q
              SQ    Yield [1, 2, 3, ..., Q]
          fP_Y      Filter that by primality
        .:      )   Yield all sublists of that
    f               Filter the sublists by:
      lY             Length
     t               -1
                    removing sublists of length 1
f                S  Filter [1, 2, 3, ..., Q] (implicit input fill) by:
  PT                 Prime factorisation
 }                   is in the sublists
                    Implicitly print

Gelée , 11 octets

ÆfÆCI=1Ȧµ€T

Pas la réponse la plus courte de Jelly, mais cette approche est plutôt efficace et la sortie est triée.

Essayez-le en ligne!

Comment ça fonctionne

ÆfÆCI=1Ȧµ€T  Main link. Argument: n

        µ€   Map the preceding chain over each k in [1, ..., n].
Æf             Compute all prime factors of k, with multiplicities.
  ÆC           Count the number of primes less than or equal to each prime factor.
               This maps the j-th to j.
    I          Increments; compute the forward differences of consecutive indices.
     =1        Compare each difference with 1.
       Ȧ       All; return 1 iff the array is non-empty and has no zeroes.
          T  Truth; yield all indices for which the chain returned 1.