任务

编写一个程序或函数，当传递数值输入时x，该函数将打印或返回x^1的平方根以下不属于的素数x。

例子

假设f(x)该函数为：

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

奖金规则

• 您可以使用您的语言提供的任何内置函数。
• 您的程序必须支持x与您的语言定义的上限一样高的输入。

¹将平方根用作仅平方根下方的素数实际上可以包含的因素x。如果没有这个限制，较大的数字将有很多多余的印刷数字。

果冻，果冻代码页中的6个字节

½ÆRḟÆf

在线尝试！

说明：

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

X^ZqGYfX-

在线尝试！

说明

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个字节

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

在线尝试！

MATLAB，57 54字节

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

非常简单，将一个素数数组提高到sqrt（p），然后删除也是p因子的任何素数。默认情况下，由于不使用分号，因此将输出最后一行的输出。

Pyth，10个字节

fP_T-S@Q2P

接受数字输入并打印列表的程序。

测试套件

怎么运行的

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个字节

tLDpϹfK

在线尝试！

说明

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

PHP，76字节

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

使用我的is_prime解决方案以$ n> 1打高尔夫球

从命令行参数获取输入。用运行-r。

Mathematica，46个字节

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

匿名函数。以数字作为输入，并返回数字列表作为输出。Unicode字符是U + 2223 DIVIDES \[Divides]。

Ruby，55个字节

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

使用内置的主要枚举器的一个相当懒惰的答案。

不可思议，14个字节

@(_> > ^#0.5)P

用法：

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

从无限质数列表中获取项目，而该项目小于参数的平方根。

Pyke，10个字节

,BS#_P)QP-

在这里尝试！

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

PowerShell v2 +，71个字节

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

迭代解决方案。接受输入$n并创建一个从1到的范围Sqrt($n)（请注意，范围运算符将隐式将高端转换为[int]，默认情况下将进行Banker的舍入）。然后使用|?{...}（Where-Object运算符，其作用类似于过滤器）提取那些$n%$_非零的数字（即，模的余数意味着它不是一个因素，并且任何非零都是真实的）-and，通常的正则表达式素数测试是$true。这些留在管道上，并且输出是隐式的。

例子

（带有一些额外的格式来漂亮地输出）

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

注意：如果输入大于左右2500000000，这将在早期版本中失败，因为..范围运算符最多只能支持50,000个项目。但是，由于它比默认[int]数据类型的最大值（）大2147483647，所以我认为这是可以的。但是，在我的机器上，PSv4 Win8.1可以继续前进，但是找不到能够解释两者差异的文档。

JavaScript（ES6），79 76字节

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

基于我的递归素性检验函数。我觉得应该有几种方法可以简化此操作，但是我不知道该怎么做...

测试片段

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>

八度，44字节

该答案的灵感来自MattWH的MATLAB答案，但我使用某些Octave特定功能对其进行了打高尔夫球。

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

这是一个接受输入的匿名函数x。Octave具有内联变量分配和索引功能，允许y首先在函数中创建（在MATLAB中无法创建），然后用作由其创建的逻辑掩码的一部分ismember（再次，在MATLAB中无法这样做）。

Perl 6、37个字节

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

展开：

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

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

这只会执行一次，然后您需要删除temp表才能在同一编辑器中再次执行

DROP TABLE #

我制作了一个版本来测试它，因为它没有在线创建表的权限，所以需要更长的时间。出于同样的原因，它不需要删除表。

在线尝试

R，58 63字节

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

将所有值从2循环到，sqrt(x)并检查它们是否与numbers包互素。x%%i计算if x mod i是0 -> Falseif i的除数，x而>0 -> Trueif i不是。

+5个字节，因为该numbers::Primes(n)函数不允许小数，但2:sqrt(x)确实可以工作，因此在if语句中添加了质数检查。

Haskell，55 54字节

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

通常是简单明了的嵌套列表推导。GCD扮演两个角色，测试y以下的数字是否为y的因数，以及测试y是否为x的因数。

隔开一点：

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

视网膜，69 66字节

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

在最大到最小的不同行上打印素数。

在线尝试！（由于最后两个测试用例，大约需要10秒。页眉和页脚启用换行分隔的测试套件，并将输出转换为逗号分隔以提高可读性。）

说明

.+
$*

将输入转换为一元。

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

这样就为输入的平方根加上了:。平方根的计算基于以下事实：的平方n也是第一n奇数整数的和。我们可以将连续的奇数整数与正向引用匹配(11\1|^1)。在此过程中，将精确使用该组的n时间，其中n平方最大的数字就是输入。

我们使用插入此数字的一元表示形式$#1$*1，然后插入冒号和匹配项本身。

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

这匹配所有适合平方根的缺失素数。素数检测基于标准的素数检查regex，然后我们只需确保刚刚捕获的素数不会将输入与第二前瞻相除。通过使用该&选项，我们得到了重叠的匹配项以确保获得所有素数。

M%`1

通过匹配1s 的数目，这会将每行（即，每个缺少的质数）转换回十进制。唯一的问题是，如果根本找不到缺失的素数，则该变量将插入零。

^0

因此，此阶段将删除该零（如果已添加）。