L'obiettivo

Scrivi un programma o una funzione che, quando viene passato un input numerico x, stampa o restituisce i numeri primi sotto la radice quadrata di x¹ che non sono fattori x.

Esempi

Lascia che f(x)sia la funzione chiamata:

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

Regole bonus

• È possibile utilizzare qualsiasi builtin fornito dalla propria lingua.
• Il tuo programma deve supportare un xinput alto come il limite superiore definito dalla tua lingua.

^{1 L'} uso della radice quadrata come solo numeri primi sotto la radice quadrata può effettivamente essere coinvolto nei fattori di x. Senza questa limitazione, numeri più grandi avrebbero molti numeri stampati in eccesso.

Jelly, 6 byte nella tabella codici di Jelly

½ÆRḟÆf

Provalo online!

Spiegazione:

½Æ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 byte

X^ZqGYfX-

Provalo online!

Spiegazione

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 byte

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

Provalo online!

MATLAB, 57 54 byte

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

Abbastanza semplice, ottiene una matrice di numeri primi fino a sqrt (p), quindi rimuove quelli che sono anche fattori di p. Stampa l'output dell'ultima riga per impostazione predefinita perché il punto e virgola viene lasciato fuori.

Pyth, 10 byte

fP_T-S@Q2P

Un programma che accetta input di un numero e stampa un elenco.

Suite di test

Come funziona

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 byte

tLDpϹfK

Provalo online!

Spiegazione

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

PHP, 76 byte

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

usa la mia soluzione is_prime golf per $ n> 1

accetta input dall'argomento della riga di comando. Corri con -r.

Mathematica, 46 byte

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

Funzione anonima. Accetta un numero come input e restituisce un elenco di numeri come output. Il carattere Unicode è U + 2223 DIVIDES per \[Divides].

Rubino, 55 byte

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

Una risposta piuttosto pigra usando l'enumeratore principale incorporato.

Meraviglia , 14 byte

@(_> > ^#0.5)P

Uso:

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

Prende elementi da un elenco infinito di numeri primi mentre l'elemento è inferiore alla radice quadrata dell'argomento.

Pyke, 10 byte

,BS#_P)QP-

Provalo qui!

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

PowerShell v2 +, 71 byte

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

Soluzione iterativa. Accetta input $ne crea un intervallo da 1a Sqrt($n)(nota che l'operatore di intervallo lancerà implicitamente l'estremità superiore in una [int]che eseguirà l'arrotondamento del banco per impostazione predefinita). Quindi usa |?{...}(l' Where-Objectoperatore, che si comporta come un filtro) per estrarre quei numeri dove $n%$_è diverso da zero (ovvero, qualsiasi resto del modulo significa che non è un fattore, e qualsiasi diverso da zero è veritiero) -andil solito test regex prime è $true. Questi vengono lasciati in cantiere e l'output è implicito.

Esempi

(con un po 'di formattazione extra per migliorare l'output)

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: Ciò non funzionerà con le versioni precedenti se l'input è maggiore di circa 2500000000, poiché l' ..operatore di gamma può supportare solo fino a 50.000 articoli. Ma, dato che è più grande del valore [int]massimo del tipo di dati predefinito 2147483647, presumo che sia OK. Sulla mia macchina, PSv4 Win8.1, tuttavia, posso andare più in alto, ma non sono in grado di trovare documentazione che spieghi la differenza.

JavaScript (ES6), 79 76 byte

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

Basato sulla mia funzione di test di primalità ricorsiva . Sento che ci dovrebbero essere alcuni modi per semplificare questo, ma non riesco a capire come ...

Snippet di prova

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>

Ottava, 44 byte

Questa risposta è ispirata alla risposta MATLAB di MattWH , ma l'ho giocata usando alcune funzionalità specifiche di Octave.

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

Questa è una funzione anonima che accetta l'input x. Octave ha l'assegnazione e l'indicizzazione delle variabili yincorporate che consentono di essere prima creati nella funzione (non possibile in MATLAB), quindi utilizzati come parte della maschera logica creata da ismember(di nuovo, non è possibile farlo in MATLAB).

Perl 6 , 37 byte

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

Allargato:

{   # 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 byte

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

Questo verrà eseguito solo una volta, quindi è necessario eliminare la tabella temporanea per eseguire nuovamente nello stesso editor

DROP TABLE #

Ho realizzato una versione per testarla, è un po 'più lunga perché le autorizzazioni online per la creazione di tabelle non sono disponibili. Per lo stesso motivo, tuttavia, non è necessaria la tabella a discesa.

Provalo online

R, 58 63 byte

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

Passa in rassegna tutti i valori da 2 a sqrt(x)e verifica se sono primi con il numberspacchetto. x%%icalcola x mod iquale è 0 -> Falseif iè un divisore di xe >0 -> Trueifi non lo è.

+5 byte perché la numbers::Primes(n)funzione non consente i decimali, mentre 2:sqrt(x)funziona, ha aggiunto il controllo primo ifall'istruzione.

Haskell, 55 54 byte

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

Comprensioni elenco nidificate per lo più semplici. GCD svolge due ruoli, verificando se i numeri sotto y sono fattori di y e verificando anche se y sia un fattore di x.

Distanziati un po ':

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

Retina , 69 66 byte

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

Stampa i numeri primi su linee separate, dal più grande al più piccolo.

Provalo online!(Richiede circa 10 secondi a causa degli ultimi due casi di test. L'intestazione e il piè di pagina abilitano una suite di test separata da avanzamento riga e convertono l'output in separazione virgola per leggibilità.)

Spiegazione

.+
$*

Converti l'input in unario.

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

Questo antepone la radice quadrata dell'input, separata da :. La radice quadrata viene calcolata in base al fatto che il quadrato di nè anche la somma dei primi nnumeri dispari. Possiamo abbinare numeri dispari consecutivi con il riferimento diretto (11\1|^1). Nel processo il gruppo verrà utilizzato esattamente nvolte, doven trova il numero più grande il cui quadrato si adatta all'input.

Inseriamo una rappresentazione unaria di questo numero con $#1$*1, seguita da due punti e dalla corrispondenza stessa.

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

Questo corrisponde a tutti i numeri primi mancanti che si adattano alla radice quadrata. Il rilevamento dei primi si basa sul regex di controllo dei primi standard e quindi ci assicuriamo semplicemente che i primi che abbiamo appena catturato non dividano l'input con il secondo lookahead. Usando l' &opzione, otteniamo corrispondenze sovrapposte per assicurarci di ottenere tutti i numeri primi.

M%`1

Questo converte ogni riga (ovvero ogni primo mancante) in decimale abbinando il numero di 1s. L'unico problema è che questo inserisce uno zero se non vengono trovati affatto numeri primi mancanti.

^0

Quindi questa fase rimuove quello zero se è stato aggiunto.