La tarea

Escriba un programa o función que, cuando se pasa una entrada numérica x, imprime o devuelve los primos debajo de la raíz cuadrada de x¹ que no son factores de x.

Ejemplos

Deje f(x)ser la función llamada:

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

Reglas de bonificación

• Puede usar cualquier componente que le proporcione su idioma.
• Su programa debe admitir una xentrada tan alta como el límite superior definido por su idioma.

^{1 El} uso de la raíz cuadrada como solo primos debajo de la raíz cuadrada puede estar involucrado dentro de los factores de x. Sin hacer esta restricción, los números más grandes tendrían una gran cantidad de números impresos en exceso.

Jelly, 6 bytes en la página de códigos de Jelly

½ÆRḟÆf

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

MATLAB, 57 54 bytes

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

Bastante sencillo, obtiene una matriz de primos hasta sqrt (p) y luego elimina los que también son factores de p. Imprime la salida de la última línea de forma predeterminada porque el punto y coma se deja desactivado.

Pyth, 10 bytes

fP_T-S@Q2P

Un programa que toma la entrada de un número e imprime una lista.

Banco de pruebas

Cómo 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

Pruébalo en línea!

Explicación

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

utiliza mi solución is_prime golfed por $ n> 1

toma datos del argumento de la línea de comando. Corre con -r.

Mathematica, 46 bytes

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

Función anónima. Toma un número como entrada y devuelve una lista de números como salida. El carácter Unicode es U + 2223 DIVIDES para \[Divides].

Ruby, 55 bytes

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

Una respuesta bastante perezosa usando el enumerador principal incorporado.

Maravilla , 14 bytes

@(_> > ^#0.5)P

Uso:

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

Toma elementos de una lista infinita de números primos, mientras que el elemento es menor que la raíz cuadrada del argumento.

Pyke, 10 bytes

,BS#_P)QP-

Pruébalo aquí!

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

Solución iterativa. Toma datos $ny crea un rango desde 1a Sqrt($n)(tenga en cuenta que el operador de rango implícitamente lanzará el extremo superior a un [int]que hará el redondeo de Banker por defecto). Luego usa |?{...}(el Where-Objectoperador, que actúa como un filtro) para extraer aquellos números donde $n%$_no es cero (es decir, cualquier resto del módulo significa que no es un factor, y cualquier otro que no sea cero es verdadero), -andla prueba de regex prima habitual es $true. Los que quedan en la tubería, y la salida es implícita.

Ejemplos

(con un formato adicional para mejorar la salida)

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

Nota: esto fallará en versiones anteriores si la entrada es mayor que alrededor 2500000000, porque el ..operador de rango solo puede admitir hasta 50,000 artículos. Pero, dado que es mayor que el valor [int]máximo del tipo de datos predeterminado 2147483647, supongo que está bien. Sin embargo, en mi máquina, PSv4 Win8.1, puedo ir más alto, pero no puedo encontrar documentación que explique la diferencia.

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

Basado en mi función de prueba de primitiva recursiva . Siento que debería haber algunas formas de simplificar esto, pero no puedo entender cómo ...

Fragmento de prueba

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>

Octava, 44 bytes

Esta respuesta está inspirada en la respuesta MATLAB de MattWH , pero la he jugado usando algunas características específicas de Octave.

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

Esta es una función anónima que toma la entrada x. Octave tiene una asignación e indexación de variables en línea que permite ycrearse primero en la función (no es posible en MATLAB), luego se usa como parte de la máscara lógica creada por ismember(nuevamente, no es posible hacerlo de esta manera en 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

Esto solo se ejecutará una vez, luego debe soltar la tabla temporal para ejecutar nuevamente en el mismo editor

DROP TABLE #

Hice una versión para probarla, es un poco más larga porque los permisos en línea para crear tablas no están disponibles. Sin embargo, por la misma razón, no necesita la tabla desplegable.

Pruébalo en línea

R, 58 63 bytes

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

Recorre todos los valores de 2 a sqrt(x)y comprueba si son primos con el numberspaquete. x%%icalcula x mod icuál es 0 -> Falsesi ies un divisor de xy >0 -> Truesii no lo es.

+5 bytes porque la numbers::Primes(n)función no permite decimales, mientras que 2:sqrt(x)sí funciona, agregó la verificación principal a la ifdeclaración.

Haskell, 55 54 bytes

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

Principalmente comprensiones sencillas de listas anidadas. GCD realiza dos roles, probando si los números debajo de y son factores de y y también si y es un factor de x.

Espaciado un poco:

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 los números primos en líneas separadas, de mayor a menor.

Pruébalo en línea! (Toma alrededor de 10 segundos debido a los dos últimos casos de prueba. El encabezado y el pie de página habilitan un conjunto de prueba separado por salto de línea y convierten la salida en separación por coma para facilitar la lectura).

Explicación

.+
$*

Convierta la entrada a unario.

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

Esto antepone la raíz cuadrada de la entrada, separada por :. La raíz cuadrada se calcula en función del hecho de que el cuadrado de nes también la suma de los primeros nenteros impares. Podemos hacer coincidir enteros impares consecutivos con la referencia directa (11\1|^1). En el proceso, el grupo se usará exactamente las nveces, donde nes el número más grande cuyo cuadrado encaja en la entrada.

Insertamos una representación unaria de este número con $#1$*1, seguido de dos puntos y la coincidencia misma.

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

Esto coincide con todos los números primos faltantes que se ajustan a la raíz cuadrada. La detección de cebado se basa en la expresión regular de verificación de cebado estándar , y luego simplemente nos aseguramos de que el cebado que acabamos de capturar no divida la entrada con la segunda búsqueda anticipada. Al usar la &opción, obtenemos coincidencias superpuestas para garantizar que obtengamos todos los números primos.

M%`1

Esto convierte cada línea (es decir, cada primo faltante) de nuevo a decimal haciendo coincidir el número de 1s. El único problema es que esto inserta un cero si no se encontraron primos faltantes.

^0

Entonces, esta etapa elimina ese cero si se agregó.