A tarefa

Escreva um programa ou função que, quando recebida uma entrada numérica x, imprima ou retorne os números primos abaixo da raiz quadrada de x¹ que não são fatores de x.

Exemplos

Let f(x)Ser a função chamada:

>>> f(4)
[]

>>> f(5)
[2]

>>> f(20)
[3]

>>> f(60)
[7]

>>> f(100)
[3, 7]

>>> f(10000)
[3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Regras do bônus

• Você pode usar quaisquer recursos internos fornecidos pelo seu idioma.
• Seu programa deve suportar uma xentrada tão alta quanto o limite superior definido pelo seu idioma.

¹ Usar a raiz quadrada como apenas números primos abaixo da raiz quadrada pode realmente estar envolvido nos fatores de x. Sem fazer essa restrição, números maiores teriam muito excesso de números impressos.

Jelly, 6 bytes na página de código de Jelly

½ÆRḟÆf

Experimente online!

Explicação:

½ÆRḟÆf
 ÆR    All primes less than or equal to
½      the square root of the input
   ḟ   but with the following removed:
    Æf All prime factors of {the input, by default}

MATL , 10 9 bytes

X^ZqGYfX-

Experimente online!

Explicação

X^    % Implicit input. Square root
Zq    % Array if primes up to that
G     % Push input again
Yf    % Array of prime factors
X-    % Set difference. Implicit display

Python 3 , 67 62 bytes

f=lambda n,k=1,m=1:k*k<n and(m%k*n%k>0)*[k]+f(n,k+1,m*k*k)or[]

Experimente online!

MATLAB, 57 54 bytes

function h(p);a=primes(p^.5);a(~ismember(a,factor(p)))

Bem simples, obtém uma matriz de números primos de até sqrt (p) e remove todos os que também são fatores de p. Imprime a saída da última linha por padrão porque o ponto e vírgula é deixado de fora.

Pitão, 10 bytes

fP_T-S@Q2P

Um programa que recebe a entrada de um número e imprime uma lista.

Suíte de teste

Como funciona

fP_T-S@Q2P   Program. Input: Q
fP_T-S@Q2PQ  Implicit input fill
f            Filter
     S@Q2    the 1-indexed range up to floor(sqrt(Q))
    -    PQ  with the prime factors of Q removed
 P_T         by primality
             Implicitly print

05AB1E , 8 bytes

tLDpϹfK

Experimente online!

Explicação

tL        # range [1 ... sqrt(input)]
  DpÏ     # keep only primes
     ¹fK  # remove factors of input

PHP, 76 bytes

for($n=1;++$n*$n<$x=$argv[1];){for($i=$n;$n%--$i;);if($i<2&&$x%$n)echo$n,_;}

usa minha solução is_prime em golfe por $ n> 1

recebe entrada do argumento da linha de comando. Corra com -r.

Mathematica, 46 bytes

Select[Prime@Range@PrimePi@Sqrt[a=#],!#∣a&]&

Função anônima. Pega um número como entrada e retorna uma lista de números como saída. O caractere Unicode é U + 2223 DIVIDES para \[Divides].

Ruby, 55 bytes

require'prime'
->x{Prime.to_a(x**0.5).select{|n|x%n>0}}

Uma resposta bastante preguiçosa usando o enumerador principal incorporado.

Maravilha , 14 bytes

@(_> > ^#0.5)P

Uso:

(@(_> > ^#0.5)P)10

Obtém itens de uma lista infinita de números primos, enquanto o item é menor que a raiz quadrada do argumento.

Pyke, 10 bytes

,BS#_P)QP-

Experimente aqui!

,B         -    int(sqrt(input))
  S        -   range(1, ^+1)
   #_P)    -  filter(^, is_prime)
         - - ^.remove(V)
       QP  -  factors(input)

PowerShell v2 +, 71 bytes

param($n)1..[math]::Sqrt($n)|?{$n%$_-and'1'*$_-match'^(?!(..+)\1+$)..'}

Solução iterativa. Recebe entrada $ne cria um intervalo de 1até a Sqrt($n)(observe que o operador de intervalo implicitamente converterá a extremidade superior para uma [int]que executará o arredondamento do banqueiro por padrão). Em seguida, os usos |?{...}(o Where-Objectoperador, que actua como um filtro) para retirar esses números onde $n%$_é diferente de zero (ou seja, qualquer restante para os meios de módulo que não é um factor, e qualquer não-zero é truthy) -ando teste privilegiada regex habitual é $true. Esses são deixados no pipeline e a produção está implícita.

Exemplos

(com alguma formatação extra para melhorar a saída)

PS C:\Tools\Scripts\golfing> 5,20,60,100,10000|%{"f($_)";(.\print-the-missing-primes.ps1 $_)-join', ';""}
f(5)
2

f(20)
3

f(60)
7

f(100)
3, 7

f(10000)
3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

NB - Isso falhará nas versões anteriores se a entrada for maior do que a existente 2500000000, porque o ..operador do intervalo pode suportar apenas até 50.000 itens. Mas, como esse é maior que o [int]valor máximo do tipo de dados padrão 2147483647, presumo que esteja OK. Na minha máquina, o PSv4 Win8.1, no entanto, posso subir mais, mas não consigo encontrar documentação explicando a diferença.

JavaScript (ES6), 79 76 bytes

f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]

Com base no meu função de teste de primalidade recursiva . Sinto que deve haver algumas maneiras de simplificar isso, mas não consigo descobrir como ...

Snippet de teste

f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]

<input type="number" step=1 min=4 value=4 oninput="O.innerHTML='['+f(this.value)+']'"><br>
<pre id=O>[]</pre>

Oitava, 44 bytes

Esta resposta é inspirada na resposta MATLAB de MattWH , mas eu a joguei usando alguns recursos específicos do Octave.

@(x)(y=primes(x^.5))(~ismember(y,factor(x)))

Esta é uma função anônima que recebe a entrada x. O Octave possui atribuição e indexação de variáveis ​​em linha, permitindo yprimeiro ser criado na função (não é possível no MATLAB), depois usado como parte da máscara lógica criada por ismember(novamente, não é possível fazê-lo dessa maneira no MATLAB).

Perl 6 , 37 bytes

{grep {$^a.is-prime&$_%$a},2.. .sqrt}

Expandido:

{   # bare block lambda with implicit parameter ｢$_｣

  grep
  {
    $^a.is-prime  # check if it is prime
    &             # and junction
    $_ % $a       # check if the input is not evenly divisible by it
  },
  2.. .sqrt          # Range of values up-to and including squareroot
}

TSQL, 130 bytes

DECLARE @v int=10000

,@ INT=2SELECT 2p INTO #
g:INSERT # SELECT @ FROM # HAVING isnull(min(@%p),1)>0SET @+=1IF @*@<@v GOTO g
SELECT*FROM # WHERE @v%p>0

Isso será executado apenas uma vez, e você precisará soltar a tabela temporária para executar novamente no mesmo editor

DROP TABLE #

Eu fiz uma versão para testá-lo, é um pouco mais longo, porque as permissões online para criar tabelas estão indisponíveis. Pelo mesmo motivo, ele não precisa da tabela suspensa.

Experimente online

R, 58 63 bytes

for(i in 2:sqrt(x<-scan()))if(x%%i&numbers::isPrime(i))print(i)

Faz um loop sobre todos os valores de 2 a sqrt(x)e verifica se eles são primos no numberspacote. x%%icalcula x mod iqual é 0 -> Falsese ié um divisor de xe >0 -> Truesei não é.

+5 bytes, porque a numbers::Primes(n)função não permite decimais, enquanto 2:sqrt(x)funciona, adicionou a verificação principal à ifinstrução.

Haskell, 55 54 bytes

f x=[y|y<-[2..x],y*y<x,[z|z<-[1..y],gcd(z*x)y>1]==[y]]

Compreensões de lista aninhadas principalmente diretas. O GCD executa duas funções, testando se os números abaixo de y são fatores de y e também testando se y é um fator de x.

Espaçado um pouco:

f x = [ y|y<-[2..x],     y*y<x,     [z|z<-[1..y], gcd (z*x) y > 1] == [y] ]

Retina , 69 66 bytes

.+
$*
(11\1|^1)+
$#1$*1:$&
M!&`(?!(11+)\1+:)(1+):(?!\2+$)
M%`1
^0

Imprime os números primos em linhas separadas, do maior para o menor.

Experimente online! (Demora cerca de 10 segundos devido aos dois últimos casos de teste. O cabeçalho e o rodapé permitem um conjunto de testes separado por avanço de linha e convertem a saída em separação por vírgula para facilitar a leitura.)

Explicação

.+
$*

Converta a entrada para unário.

(11\1|^1)+
$#1$*1:$&

Anexa a raiz quadrada da entrada, separada por :. A raiz quadrada é calculada com base no fato de que o quadrado de ntambém é a soma dos primeiros nnúmeros inteiros ímpares. Podemos combinar inteiros ímpares consecutivos com a referência direta (11\1|^1). No processo, o grupo será usado exatamente nvezes, onden é o maior número cujo quadrado se encaixa na entrada.

Nós inserimos uma representação unária desse número com $#1$*1, seguida por dois pontos e a própria correspondência.

M!&`(?!(11+)\1+:)(1+):(?!\2+$)

Isso corresponde a todos os números primos ausentes que se encaixam na raiz quadrada. A detecção de prime é baseada no regex padrão de verificação de prime e, em seguida, simplesmente garantimos que o prime que capturamos não divida a entrada com o segundo lookahead. Ao usar a &opção, obtemos correspondências sobrepostas para garantir que obtemos todos os números primos.

M%`1

Isso converte cada linha (ou seja, cada primo ausente) de volta em decimal, correspondendo ao número de 1s. O único problema é que isso insere um zero se nenhum número primo ausente for encontrado.

^0

Portanto, esse estágio remove esse zero se ele foi adicionado.