On m'a posé cette question dans une interview mais je n'ai pas pu trouver de solution. Je ne sais pas si la question était vraie ou non. J'ai beaucoup essayé mais je n'ai trouvé aucune solution. Honnêtement, rien ne m'est venu à l'esprit.

Numéros de Rocco

Un entier positif est un nombre de Rocco s'il peut être représenté par ou , où est un nombre premier.$n$$n=p(p+14)$$n=p(p-14)$$p$

Les 10 premiers numéros Rocco sont:

Tâche

Votre code doit accepter un entier positif en entrée et déterminer s'il s'agit d'un nombre Rocco ou non.

Points de brownie

• Écrivez une fonction qui calcule et imprime le nombre de nombres Rocco inférieur ou égal à 1 million.
• Écrivez une fonction qui calcule et imprime le nombre de nombres Rocco de la question bonus (ci-dessus) qui sont premiers.

05AB1E , 8 octets

Renvoie si est un nombre Rocco, ou sinon.$1$$n$$0$

fDŠ/α14å

Essayez-le en ligne!

Comment?

Étant donné un entier positif , nous testons s'il existe un facteur premier de tel que:$n$$p$$n$

Commenté

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 octets

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

Essayez-le en ligne!

Comment?

Étant donné un entier positif , nous recherchons un nombre premier tel que ou .$n$$x$$x(x+14)=n$$x(x-14)=n$

D'où les équations quadratiques suivantes:

La racine positive de est:$(1)$

et la racine positive de est:$(2)$

Par conséquent, le problème équivaut à tester si ou est premier.$x_0$$x_1$

Pour ce faire, nous utilisons la fonction de test de primalité récursive classique, avec un test supplémentaire pour nous assurer qu'il ne boucle pas indéfiniment s'il reçoit un numéro irrationnel en entrée.

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)

Fonction d'enveloppe principale:

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

Perl 6 , 45 28 octets

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

Essayez-le en ligne!

Utilise la construction d'Arnauld , que doit être premier pour que soit un nombre de Rocco.$\sqrt{n+49}\pm7$$n$

Explication:

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

Regex (ECMAScript), 64 62 octets

Cette expression régulière trouve deux nombres et tels que . S'il les trouve, il affirme alors que ou est premier. C'est ça!$a$$a+14$$n=a(a+14)$$a$$a+14$

Cela utilise une variante de l'algorithme de multiplication brièvement décrit dans un paragraphe de mon post regex de nombres abondants . Ceci est un spoiler . Alors ne lisez pas plus loin si vous ne voulez pas que la magie des regex unaires avancées soit gâtée pour vous . Si vous voulez essayer de découvrir cette magie vous-même, je vous recommande vivement de commencer par résoudre certains problèmes dans la liste des problèmes recommandés marqués consécutivement par spoiler dans ce post précédent , et d'essayer de trouver les idées mathématiques de manière indépendante.

L'algorithme de multiplication est implémenté différemment ici parce que nous affirmons que deux valeurs connues multipliées ensemble égalent une autre valeur connue (comme cela est également fait dans la version alternative de l'expression régulière dans ce post , pour tester si un nombre est un carré parfait). Dans la plupart de mes autres réponses regex publiées jusqu'à présent, la multiplication est implémentée comme un calcul (pas une assertion, conceptuellement parlant) où le but est de trouver le produit de deux nombres connus. Les deux méthodes fonctionnent dans les deux circonstances, mais au niveau du golf, elles sont plus mauvaises à faire le travail l'une de l'autre.

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

Essayez-le en ligne!

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

ṗ;14{+|-};?×

Entrez le numéro du candidat comme argument de ligne de commande. Sorties trueou false. Essayez-le en ligne!

Explication

Le code est un prédicat dont l'entrée n'est pas contrainte et dont la sortie est le nombre que nous testons.

ṗ             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

(Les pourboires sont les bienvenus. Cela {+|-}semble toujours maladroit.)

Brachylog , 9 octets

Approche différente alors DLosc de réponse

Ċ-14&∋ṗ&×

Prend N comme sortie, renvoie [P, P-14] ou [P + 14, P] via l'entrée (le plus grand nombre en premier)

explication

Ċ              # 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)

Essayez-le en ligne!

Pyth, 22 20 octets

}Qsm*Ld+Ld_B14fP_TSh

Essayez-le en ligne ici .

}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

Edit: les 3 octets enregistrés en entrée seront toujours positifs, donc pas besoin de filtrer les valeurs négatives de la liste. Correction d'un bug pour les entrées 1et 2coûtant 1 octet. La version précédente:}Qsm*Ld>#0+Ld_B14fP_TU

05AB1E , 16 15 14 octets

Enregistré 1 octet en calculant 14 avec 7·au lieu de žvÍ(je ne peux pas croire que je n'y ai pas pensé en premier lieu).

1 octet enregistré grâce à Emigna

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

Essayez-le en ligne! ou Testez toutes les entrées

Explication

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

Basé sur la solution d'Arnauld :

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

Essayez-le en ligne!

Tentative précédente:

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

Essayez-le en ligne!

Retina 0.8.2 , 61 octets

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

Essayez-le en ligne! Explication:

.+
$*

Convertissez en unaire.

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

\1saisit le plus grand des deux facteurs. \2capture la constante 14, économisant un octet. \3capture le plus petit des deux facteurs, moins 1. Cela garantit également que les deux facteurs sont au moins 2.

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

Vérifiez les deux facteurs pour vous assurer qu'au moins l'un d'entre eux est premier. L'idée d'utiliser a \2?été impudiquement volée dans la réponse de @ Deadcode.

(?<-3>\1)+

Répétez le plus grand des deux facteurs un nombre de fois égal à un de moins que le plus petit des deux facteurs. Comme nous avons déjà capturé le facteur le plus important, cela finit par capturer le produit des deux facteurs.

$(?(3)1)

Assurez-vous que le produit est égal au nombre donné.

Une traduction directe vers Retina 1 en remplaçant $*par *1aurait le même nombre d'octets, mais un octet pourrait être enregistré en remplaçant tous les 1s par _s, puis *1pourrait être remplacé par *plutôt que *_. Réponse précédente de Retina 1 pour 68 octets:

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

0m`^_{14}$

Essayez-le en ligne! Explication:

.+
*

Convertissez en unaire.

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

Trouvez toutes les paires de facteurs.

Am` (__+)\1+$

Assurez-vous que l'un est premier.

(_+) \1

Prenez la différence absolue.

0m`^_{14}$

Vérifiez s'il y en a 14.

JavaScript (Babel Node) , 69 octets

Merde, je pensais que j'allais battre la réponse d'Arnaulds mais non .....: c

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

Essayez-le en ligne!

Je veux me débarrasser de la x=>[...Array(x)].some(pièce en utilisant la récursivité afin qu'elle puisse se raccourcir avec le temps

Explication

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

Il utilise la formule

Japt , 10 octets

Identique à ma réponse Javascript

k d@/X-X¥E

Essayez-le en ligne!

Gelée , 9 octets

:ạ⁹ɗÆf14e

Essayez-le en ligne!

APL (NARS) 16 caractères, 32 octets

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

{π⍵} trouverait la factorisation de son argument et nous supposons que le dernier élément de son résultat (la liste des diviseurs de n) est le diviseur premier maximum de n; Ici, nous supposons qu'une définition équivalente du nombre de Rocco est: n est un nombre de Rocco <=> facteur maximal premier de n: r est tel qu'il est vrai 14 = ∣rn ÷ r [pour le pseudocode C comme 14 == abs (rn / r) cette définition du nombre de Rocco semble enfin correcte dans la plage 1..1000000]; la plage de valeurs ok serait 1..maxInt; tester:

 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 # Interactive Compiler) , 99 octets

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

Essayez-le en ligne!

Enumerable.Range frappe à nouveau :) En utilisant le drapeau fou du compilateur, vous pouvez réduire les choses un peu, même si je suis un peu fan de la solution vanilla.

C # (Visual C # Interactive Compiler) + /u:System.Linq.Enumerable, 77 octets

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

Essayez-le en ligne!

Ci-dessous est un portage de la solution d'Arnauld qui semblait assez cool. C'est actuellement le plus long, mais il peut probablement être joué au golf.

C # (Visual C # Interactive Compiler) , 101 octets

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));}

Essayez-le en ligne!

APL (NARS) 30 caractères, 60 octets

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

Ici 0π est la fonction disons si un nombre est premier, test:

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

F #, 2 réponses (non concurrentes)

J'ai vraiment aimé les réponses de @Arnauld, alors je les ai traduites.

123 octets , basé sur la réponse 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(||)

Explication:

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 octets , basé sur la réponse 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

Explication:

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 octets

Sorties par code de sortie, échoue ( 1) pour les numéros Rocco.

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

Essayez-le en ligne!