No momento da submissão à sandbox, eu tinha 17017 a reputação, que todos vocês podem considerar como 7 × 11 × 13 × 17, um produto de quatro primos consecutivos.

Escreva uma função ou programa para produzir todos os produtos de dois ou mais primos consecutivos até um número inteiro de entrada n. Por exemplo, dado que n=143você deve produzir 6, 15, 30, 35, 77, 105, 143(ou formato de saída equivalente).

Aplicam-se restrições normais de E / S e brechas.

Isso é código-golfe , então o programa mais curto vence.

Geléia , 14 10 bytes

(sem dúvida, há golfe para fazer aqui! - sim ...)
-4 bytes graças a @Dennis - substitua a verificação por maior que n usando um intervalo

ÆRẆP€ḟÆRfR

Nota - isso é extremamente ineficiente e os resultados não são classificados.

Teste em TryItOnline

Quão?

Æ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 bytes

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

Abordagem semelhante à da resposta de Jonathan Allan .

Experimente online!

Versão antiga, 25 bytes

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

Isso obtém os expoentes da decomposição do fator primo para todos os números da 1entrada. Para cada uma delas verifica:

1. Se todos os expoentes forem menores que 2.
2. Se a soma de todos os expoentes for maior que 1.
3. A matriz de expoentes é estendida com um zero adicional em cada extremidade. As diferenças consecutivas da matriz estendida são calculadas. Deve haver exatamente 2 diferenças diferentes de zero.

Se as três condições forem atendidas, o número será exibido. Os resultados estão em ordem crescente.

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

Demo

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 bytes

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

Explicação

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

Experimente online!

Pitão, 18 bytes

f}PTftlY.:fP_YSQ)S

Um programa que recebe a entrada de um número inteiro em STDIN e imprime uma lista de números inteiros.

Experimente online

Como funciona

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

Gelatina , 11 bytes

ÆfÆCI=1Ȧµ€T

Não é a resposta mais curta do Jelly, mas essa abordagem é bastante eficiente e a saída é classificada.

Experimente online!

Como funciona

Æ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.