Die Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die bei Übergabe einer numerischen Eingabe xdie Primzahlen unter der Quadratwurzel von x¹ ausgibt oder zurückgibt , die keine Faktoren von sind x.

Beispiele

Sei f(x)die aufgerufene Funktion:

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

Bonusregeln

• Sie können alle von Ihrer Sprache bereitgestellten integrierten Funktionen verwenden.
• Ihr Programm muss eine xEingabe unterstützen, die so hoch ist wie die von Ihrer Sprache festgelegte Obergrenze.

^{1 Die} Verwendung der Quadratwurzel als nur Primzahlen unterhalb der Quadratwurzel kann tatsächlich in die Faktoren von einbezogen werden x. Ohne diese Einschränkung hätten größere Zahlen eine Menge überschüssiger gedruckter Zahlen.

Jelly, 6 Bytes in Jellys Codepage

½ÆRḟÆf

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

MATLAB, 57 54 Bytes

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

Ziemlich einfach, erhält eine Reihe von Primzahlen bis zu sqrt (p) und entfernt dann alle, die auch Faktoren von p sind. Druckt standardmäßig die Ausgabe der letzten Zeile, da das Semikolon weggelassen wird.

Pyth, 10 Bytes

fP_T-S@Q2P

Ein Programm, das eine Zahl eingibt und eine Liste druckt.

Testsuite

Wie es funktioniert

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

Probieren Sie es online!

Erläuterung

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,_;}

verwendet meine is_prime-Lösung für $ n> 1

Nimmt Eingaben vom Kommandozeilenargument entgegen. Laufen Sie mit -r.

Mathematica, 46 Bytes

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

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Liste von Zahlen als Ausgabe zurück. Das Unicode-Zeichen ist U + 2223 DIVIDES für \[Divides].

Ruby, 55 Bytes

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

Eine eher faule Antwort mit dem eingebauten Primenzähler.

Wunder , 14 Bytes

@(_> > ^#0.5)P

Verwendung:

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

Nimmt Elemente aus einer unendlichen Liste von Primzahlen, während das Element kleiner als die Quadratwurzel des Arguments ist.

Pyke, 10 Bytes

,BS#_P)QP-

Probieren Sie es hier aus!

,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+$)..'}

Iterative Lösung. Übernimmt Eingaben $nund erstellt einen Bereich von 1bis Sqrt($n)(der Bereichsoperator setzt implizit das obere Ende auf einen [int]Wert, der standardmäßig die Bankerrundung ausführt). Verwendet dann |?{...}(der Where-ObjectBedienungsperson , die sich wie ein Filter wirkt) , um diese Zahlen herausziehen , wo $n%$_nicht Null ist (dh jeder Rest den modulo Mitteln ist es kein Faktor, und jeder Nicht-Null ist truthy) -anddie üblichen regex prime Test ist $true. Diese verbleiben in der Pipeline, und die Ausgabe ist implizit.

Beispiele

(Mit etwas zusätzlicher Formatierung, um die Ausgabe zu verbessern)

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 - Dies schlägt in früheren Versionen fehl, wenn die Eingabe größer als ungefähr ist 2500000000, da der ..Bereichsoperator nur bis zu 50.000 Elemente unterstützen kann. Da dies jedoch größer ist als der [int]Maximalwert des Standarddatentyps 2147483647, gehe ich davon aus, dass dies in Ordnung ist. Auf meinem Computer, PSv4 Win8.1, kann ich zwar eine höhere Version verwenden, aber keine Dokumentation finden, die den Unterschied erklärt.

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

Basierend auf meiner rekursiven Primalitätstestfunktion . Ich bin der Meinung, dass es ein paar Möglichkeiten geben sollte, dies zu vereinfachen, aber ich kann nicht herausfinden, wie ...

Testschnipsel

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>

Oktave, 44 Bytes

Diese Antwort ist von der MATLAB-Antwort von MattWH inspiriert , aber ich habe sie mit einigen Octave-spezifischen Funktionen gespielt.

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

Dies ist eine anonyme Funktion, die die Eingabe übernimmt x. Octave verfügt über eine Inline-Variablenzuweisung und -Indizierung, die es ermöglicht y, zuerst in der Funktion erstellt zu werden (in MATLAB nicht möglich) und dann als Teil der von erstellten logischen Maske verwendet zu werden ismember(in MATLAB ebenfalls nicht möglich).

Perl 6 , 37 Bytes

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

Erweitert:

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

Dies wird nur einmal ausgeführt. Anschließend müssen Sie die temporäre Tabelle löschen, um sie erneut im selben Editor auszuführen

DROP TABLE #

Ich habe eine Testversion erstellt, die etwas länger ist, da die Online-Berechtigungen zum Erstellen von Tabellen nicht verfügbar sind. Aus dem gleichen Grund wird die Drop-Tabelle jedoch nicht benötigt.

Probieren Sie es online aus

R 58 63 Bytes

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

Durchläuft alle Werte von 2 bis sqrt(x)und prüft, ob sie mit dem numbersPaket übereinstimmen . x%%iberechnet, x mod iwelches ist, 0 -> Falsewenn iein Teiler von xund >0 -> Truewenn isti nicht.

+5 Bytes, da die numbers::Primes(n)Funktion keine Dezimalstellen zulässt, während 2:sqrt(x)dies funktioniert if. Der Anweisung wurde eine Primzahlprüfung hinzugefügt .

Haskell, 55 54 Bytes

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

Meist einfaches Verständnis von verschachtelten Listen. GCD führt zwei Rollen aus, indem es prüft, ob die Zahlen unter y Faktoren von y sind und ob y ein Faktor von x ist.

Ein wenig Abstand:

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

Druckt die Primzahlen in separaten Zeilen vom größten zum kleinsten.

Probieren Sie es online! (Dauert aufgrund der letzten beiden Testfälle ca. 10 Sekunden. Kopf- und Fußzeile ermöglichen eine Testsuite mit Zeilenvorschub und konvertieren die Ausgabe zur besseren Lesbarkeit in Kommatrennung.)

Erläuterung

.+
$*

Konvertieren Sie die Eingabe in Unary.

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

Dies stellt die Quadratwurzel der Eingabe voran, getrennt durch :. Die Quadratwurzel wird basierend auf der Tatsache berechnet, dass das Quadrat von nauch die Summe der ersten nungeraden ganzen Zahlen ist. Wir können aufeinanderfolgende ungerade ganze Zahlen mit der Vorwärtsreferenz abgleichen (11\1|^1). Dabei wird die Gruppe genau nmal benutzt, won es die größte Zahl ist, deren Quadrat in die Eingabe passt.

Wir fügen eine unäre Darstellung dieser Zahl mit ein $#1$*1, gefolgt von einem Doppelpunkt und der Übereinstimmung selbst.

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

Dies entspricht allen fehlenden Primzahlen, die in die Quadratwurzel passen. Die Primerkennung basiert auf dem regulären regulären Ausdruck für die Primprüfung , und dann stellen wir einfach sicher, dass die soeben erfasste Primzahl die Eingabe nicht durch den zweiten Lookahead teilt. Mit dieser &Option erhalten wir überlappende Übereinstimmungen, um sicherzustellen, dass wir alle Primzahlen erhalten.

M%`1

Dies konvertiert jede Zeile (dh jedes fehlende Primzeichen) zurück in eine Dezimalzahl, indem es der Anzahl von 1s entspricht. Das einzige Problem ist, dass dies eine Null einfügt, wenn überhaupt keine fehlenden Primzahlen gefunden wurden.

^0

Diese Stufe entfernt also diese Null, wenn sie hinzugefügt wurde.