采访中有人问我这个问题，但我找不到解决办法。我不知道这个问题是否对。我尝试了很多，但无法解决。老实说，我什么都没想到。

罗科数

如果正整数$n$可以表示为$n=p(p+14)$或$n=p(p-14)$，其中$p$是质数，则为Rocco 数。

前10个Rocco号码是：

任务

您的代码必须接受一个正整数作为输入，并确定它是否是Rocco数字。

印象分

• 编写一个函数，计算并打印小于或等于100万的Rocco数。
• 编写一个函数，该函数根据质数的奖金问题（上面的问题）计算并打印Rocco数的计数。

05AB1E，8个字节

如果n是Rocco数，则返回$1$，否则返回0。$n$$0$

fDŠ/α14å

在线尝试！

怎么样？

给定一个正整数$n$，我们测试是否存在素数$p$为$n$，使得：

已评论

fDŠ/α14å  # expects a positive integer n as input       e.g. 2655
f         # push the list of unique prime factors of n  -->  2655, [ 3, 5, 59 ]
 D        # duplicate it                                -->  2655, [ 3, 5, 59 ], [ 3, 5, 59 ]
  Š       # moves the input n between the two lists     -->  [ 3, 5, 59 ], 2655, [ 3, 5, 59 ]
   /      # divide n by each prime factor               -->  [ 3, 5, 59 ], [ 885, 531, 45 ]
    α     # compute the absolute differences
          # between both remaining lists                -->  [ 882, 526, 14 ]
     14å  # does 14 appear in there?                    -->  1

JavaScript（ES7），55个字节

n=>(g=k=>k>0&&n%--k?g(k):k==1)(n=(49+n)**.5-7)|g(n+=14)

在线尝试！

怎么样？

$n$$x$$x(x+14)=n$$x(x-14)=n$

因此，下面的二次方程式：

$(1)$

$(2)$

$x_0$$x_1$

为此，我们使用经典的递归素性测试函数，并进行额外的测试，以确保如果给定一个无理数作为输入，它不会永远循环。

g = k =>    // k = explicit input; this is the divisor
            // we assume that the implicit input n is equal to k on the initial call
  k > 0 &&  // abort if k is negative, which may happen if n is irrational
  n % --k ? // decrement k; if k is not a divisor of n:
    g(k)    //   do a recursive call
  :         // else:
    k == 1  //   returns true if k is equal to 1 (n is prime)
            //   or false otherwise (n is either irrational or a composite integer)

主要包装器功能：

n => g(n = (49 + n) ** .5 - 7) | g(n += 14)

Perl 6的，45 28个字节

((*+49)**.5+(7|-7)).is-prime

在线尝试！

$\sqrt{n+49}\pm7$$n$

说明：

 (*+49)**.5                   # Is the sqrt of input+49
           +(7|-7)            # Plus or minus 7
(                 ).is-prime  # Prime?

正则表达式（ECMAScript），64 62字节

$a$$a+14$$n=a(a+14)$$a$$a+14$

这使用了乘法算法的一种变体，在我大量的正则表达式帖子的一段中进行了简要描述。这是一个破坏者。因此，如果您不想破坏一些高级一元正则表达式魔术，请不要继续阅读。如果您确实想自己弄清楚该魔术，我强烈建议您从解决此较早文章中连续扰流器标记的推荐问题列表中的一些问题开始，并尝试独立提出数学见解。

乘法算法在此处的实现方式有所不同，因为我们断言两个已知值相乘等于另一个已知值（也可以在本文中的正则表达式的替代版本中进行此操作，以测试一个数字是否为理想平方）。到目前为止，在我发布的大多数其他正则表达式答案中，乘法都是作为计算（从概念上来说不是断言）来实现的，目的是找到两个已知数字的乘积。两种方法都在两种情况下都有效，但是在高尔夫方面，彼此的工作效果更差。

^(?=(x((x{14})(x+)))(?=(\1*)\4\2*$)(\1*$\5))\6\3?(?!(xx+)\7+$)

在线尝试！

 # For the purposes of these comments, the input number = N.
 ^
 # Find two numbers A and A+14 such that A*(A+14)==N.
 (?=
     (x((x{14})(x+)))   # \1 = A+14; \2 = \1-1; \3 = 14; \4 = A-1; tail -= \1
     (?=                # Assert that \1 * (\4+1) == N.
         (\1*)\4\2*$    # We are asserting that N is the smallest number satisfying
                        # two moduli, thus proving it is the product of A and A+14
                        # via the Chinese Remainder Theorem. The (\1*) has the effect
                        # of testing every value that satisfies the "≡0 mod \1"
                        # modulus, starting with the smallest (zero), against "\4\2*$",
                        # to see if it also satisfies the "≡\4 mod \2" modulus; if any
                        # smaller number satisfied both moduli, (\1*) would capture a
                        # nonzero value in \5. Note that this actually finds the
                        # product of \4*\1, not (\4+1)*\1 which what we actually want,
                        # but this is fine, because we already subtracted \1 and thus
                        # \4*\1 is the value of tail at the start of this lookahead.
                        # This implementation of multiplication is very efficient
                        # golf-wise, but slow, because if the number being tested is
                        # not even divisible by \1, the entire test done inside this
                        # lookahead is invalid, and the "\1*$" test below will only
                        # fail after this useless test has finished.
     )
     (\1*$\5)           # Assert that the above test proved \1*(\4+1)==N, by
                        # asserting that tail is divisible by \1 and that \5==0;
                        # \6 = tool to make tail = \1
 )
 # Assert that either A or A+14 is prime.
 \6                     # tail = \1 == A+14
 \3?                    # optionally make tail = A
 (?!(xx+)\7+$)          # Assert tail is prime. We don't need to exclude treating
                        # 1 as prime, because the potential false positive of N==15
                        # is already excluded by requiring \4 >= 1.
 

Brachylog，13 12字节

ṗ;14{+|-};?×

输入候选号码作为命令行参数。输出true或false。在线尝试！

说明

该代码是谓词，其输入不受限制，其输出是我们正在测试的数字。

ṗ             Let the input ? be a prime number
 ;14          Pair it with 14, yielding the list [?, 14]
    {+|-}     Either add or subtract, yielding ?+14 or ?-14
         ;?   Pair the result with the input, yielding [?+14, ?] or [?-14, ?]
           ×  Multiply; the result must match the candidate number

（欢迎小贴士。这{+|-}仍然很笨拙。）

Brachylog，9个字节

不同于DLosc的答案

Ċ-14&∋ṗ&×

以N为输出，通过输入返回[P，P-14]或[P + 14，P]（从大到大）

说明

Ċ              # The 'input' is a pair of numbers
 -14           #   where the 2nd is 14 smaller then the first
    &∋ṗ        #   and the pair contains a prime
       &×      #   and the numbers multiplied give the output (N)

在线尝试！

Pyth，22 20字节

}Qsm*Ld+Ld_B14fP_TSh

在这里在线尝试。

}Qsm*Ld+Ld_B14fP_TShQ   Implicit: Q=eval(input())
                        Trailing Q inferred
                  ShQ   Range [1-(Q+1)]
              fP_T      Filter the above to keep primes
   m                    Map the elements of the above, as d, using:
          _B14            [14, -14]
       +Ld                Add d to each
    *Ld                   Multiply each by d
  s                     Flatten result of map
}Q                      Is Q in the above? Implicit print

编辑：保存为输入的3个字节将始终为正，因此无需从列表中过滤出负值。还修复了输入1和的错误2，花费1个字节。先前版本：}Qsm*Ld>#0+Ld_B14fP_TU

05AB1E，16 15 14字节

通过计算14 7·代替节省了1个字节žvÍ（不能相信我一开始就没有想到这一点）。

感谢Emigna节省了1个字节

ÅPε7·D(‚+y*Q}Z

在线尝试！或测试所有输入

说明

                 # Implicit input n
ÅP               # Push a list of primes up to n
  ε         }    # For each prime in the list...
   7·            # Push 14 (by doubling 7)
     D(‚         # Push -14 and pair them together to get [14,-14]
        +        # Add [14,-14] to the prime
         y*      # Multiply the prime to compute p(p-14) and p(p+14)
           Q     # Check if the (implicit) input is equal to each element
             Z   # Take the maximum

J，21 15字节

基于Arnauld的解决方案：

14 e.q:|@-(%q:)

在线尝试！

先前的豁免：

e.&,14&(]*+,-~)@p:@i.

在线尝试！

视网膜0.8.2，61字节

.+
$*
^((1{14})1(1)+)(?<=(?<!^\4+(..+))\2?)(?<-3>\1)+$(?(3)1)

在线尝试！说明：

.+
$*

转换为一元。

^((1{14})1(1)+)

\1捕获两个因素中较大的一个。\2捕获常量14，保存一个字节。\3捕获两个因子中较小的负1。这还确保两个因子至少为2。

(?<=(?<!^\4+(..+))\2?)

检查两个因素，以确保其中至少一个是主要因素。\2?@Deadcode的答案无耻地窃取了使用的想法。

(?<-3>\1)+

重复两次较大的因子等于两次小于较小的因子。由于我们已经捕获了较大的因子，因此最终捕获了两个因子的乘积。

$(?(3)1)

确保产品等于给定的数字。

通过更换一个直接翻译的Retina 1 $*与*1将具有相同的字节数，但一个字节可以更换所有的保存1与S _秒，然后将*1可能被替换*，而不是*_。上一个Retina 1答案为68个字节：

.+
*
Lw$`^(__+)(?=(\1)+$)
$1 _$#2*
Am` (__+)\1+$
(_+) \1

0m`^_{14}$

在线尝试！说明：

.+
*

转换为一元。

Lw$`^(__+)(?=(\1)+$)
$1 _$#2*

找到所有成对的因素。

Am` (__+)\1+$

确保一个是素数。

(_+) \1

取绝对差。

0m`^_{14}$

检查是否有14。

JavaScript（Babel节点），69字节

该死的，尽管我要击败Arnaulds的答案，但是没有.....：c

x=>[...Array(x)].some((a,b)=>x/(a=(p=n=>--b-1?n%b&&p(n):n)(b))-a==14)

在线尝试！

我想摆脱x=>[...Array(x)].some(使用递归的部分，所以随着时间的推移可能会变得更短

说明

x=>[...Array(x)]                                                              Creates a range from 0 to x-1 and map:

                .some((a,b)=>                                                 Returns True if any of the following values is true
                             x/                                              Input number divided by
                                (a=(p=n=>--b-1?n%b&&p(n):n)(b))               recursive helper function. Receives a number (mapped value) as parameters and returns 
                                                                              the same number if it is prime, otherwise returns 1. Take this value
                                                                              and assign to variable a
                                                               -a            Subtract a from the result  
                                                                     ==14    Compare result equal to 14

它使用公式

Japt，10字节

与我的Javascript答案相同

k d@/X-X¥E

在线尝试！

果冻，9字节

:ạ⁹ɗÆf14e

在线尝试！

APL（NARS）16个字符，32个字节

{14=∣r-⍵÷r←↑⌽π⍵}

{π⍵}将找到其参数的因式分解，我们假设其结果的最后一个元素（n的除数的列表）是n的最大素数。在这里，我们假设Rocco数的一个等效定义是：n是n的Rocco数<=>最大因数素数：r使得它为真14 = ∣rn÷r [对于C伪代码为14 == abs（rn / r）这个Rocco编号的定义在1..1000000]的范围内看起来还可以。ok值的范围为1..maxInt; 测试：

 f←{14=∣r-⍵÷r←↑⌽π⍵}
 {⍞←{1=f ⍵:' ',⍵⋄⍬}⍵⋄⍬}¨1..10000
32  51  95  147  207  275  351  435  527  627  851  1107  1247  1395  1551  1887  2067  2255  2451  2655  2867  3551  4047  4307  4575  5135  5427  5727  6035  6351  6675  7347  8051  8787  9167  9951   

C＃（Visual C＃交互式编译器），99字节

n=>Enumerable.Range(2,n).Any(p=>Enumerable.Range(2,p).All(y=>y>=p|p%y>0)&(n==p*(p+14)|n==p*(p-14)))

在线尝试！

Enumerable.Range 再次罢工：）使用疯狂的编译器标志，您可以减少很多工作，尽管我有点喜欢普通解决方案。

C＃（Visual C＃交互式编译器） + /u:System.Linq.Enumerable，77字节

n=>Range(2,n).Any(p=>Range(2,p).All(y=>y>=p|p%y>0)&(n==p*(p+14)|n==p*(p-14)))

在线尝试！

下面是Arnauld解决方案的一部分，看起来很酷。它是目前最长的，但也有可能打高尔夫球。

C＃（Visual C＃交互式编译器），101字节

n=>{bool g(int k)=>--k<2?n>1:n%k>0&g(k);var d=Math.Sqrt(n+49)-7;return(n=(int)d)==d&(g(n)|g(n+=14));}

在线尝试！

APL（NARS）30个字符，60个字节

{∨/{0=1∣⍵:0π⍵⋄0}¨(7,¯7)+√49+⍵}

这里0π是一个函数，如果一个数字是质数，则测试：

 f←{∨/{0=1∣⍵:0π⍵⋄0}¨(7,¯7)+√49+⍵}
 {⍞←{1=f ⍵:' ',⍵⋄⍬}⍵⋄⍬}¨0..700
32  51  95  147  207  275  351  435  527  627

F＃，2个答案（非竞争）

我真的很喜欢@Arnauld的答案，所以我翻译了它们。

123个字节，基于JavaScript答案

fun n->let t=int<|sqrt(float n+49.)in Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)[t-7;t+7]|>Seq.reduce(||)

说明：

fun n->let t=int<|sqrt(float n+49.)in Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)[t-7;t+7]|>Seq.reduce(||) //Lambda which takes an integer, n
       let t=int<|sqrt(float n+49.)                                                                                         //let t be n, converted to float, add 49 and get square root, converted back to int (F# type restrictions)
                                   in                                                                                       //in the following...
                                                                                                  [t-7;t+7]                 //Subtract and add 7 to t in a list of 2 results (Lists and Seqs can be interchanged various places)
                                      Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)                          //See if either are prime (here, if either result has 2 and only 2 divisors)
                                                                                                           |>Seq.reduce(||) //And logically OR the resulting sequence

125字节，基于05AB1E答案

fun n->let l=Seq.filter(fun i->n%i=0)[2..n-1]in let m=Seq.map(fun i->n/i)l in Seq.map2(fun a b->abs(a-b))l m|>Seq.contains 14

说明：

fun n->let l=Seq.filter(fun i->n%i=0)[2..n-1]in let m=Seq.map(fun i->n/i)l in Seq.map2(fun a b->abs(a-b))l m|>Seq.contains 14  //Lambda which takes an integer, n
       let l=Seq.filter(fun i->n%i=0)[2..n-1]                                                                                  //let l be the list of n's primes 
                                             in                                                                                //in...
                                                let m=Seq.map(fun i->n/i)l                                                     //m, which is n divided by each of l's contents
                                                                           in                                                  //and then...
                                                                              Seq.map2(fun a b->abs(a-b))l m                   //take the absolute difference between each pair of items in the two sequences to make a new sequence
                                                                                                            |>Seq.contains 14  //and does the resulting sequence contain the number 14?

Python 2，58字节

1Rocco编号输出的退出代码失败（）。

P=k=1.
n=input()
exec"P*=k*k;k+=1;P%k*abs(n/k-k)==14>y;"*n

在线尝试！