Bir röportajda bu soru soruldu, ancak herhangi bir çözüm bulamadım. Sorunun doğru olup olmadığını bilmiyorum. Çok denedim ama herhangi bir çözüme ulaşamadım. Dürüst olmak gerekirse, aklıma hiçbir şey gelmedi.

Rocco numaraları

Pozitif bir tamsayısı , veya olarak gösterilebiliyorsa, bir Rocco numarasıdır ; burada , asal bir sayıdır.$n$$n=p(p+14)$$n=p(p-14)$$p$

İlk 10 Rocco numarası:

Görev

Kodunuz girdi olarak pozitif bir tamsayıyı kabul etmeli ve bir Rocco numarası olup olmadığını belirlemelidir.

Brownie puanları

• 1 milyondan küçük veya ona eşit Rocco sayılarının sayısını hesaplayan ve yazdıran bir işlev yazın.
• Asal olan bonus sorudan (üstte) Rocco sayılarının sayısını hesaplayan ve yazdıran bir fonksiyon yazın.

05AB1E , 8 bayt

bir Rocco numarası ise , aksi takdirde değerini döndürür .$1$$n$$0$

fDŠ/α14å

Çevrimiçi deneyin!

Nasıl?

Pozitif tam sayı Verilen bir asal çarpan orada olup olmadığını, biz testi ait öyle ki:$n$$p$$n$

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Nasıl?

Pozitif bir tamsayısı verildiğinde , veya olacak şekilde bir asal arıyoruz .$n$$x$$x(x+14)=n$$x(x-14)=n$

Dolayısıyla aşağıdaki ikinci dereceden denklemler:

in pozitif kökü :$(1)$

ve nin pozitif kökü :$(2)$

Bu nedenle, sorun veya asal olup olmadığını sınamaya eşdeğerdir .$x_0$$x_1$

Bunu yapmak için, giriş olarak irrasyonel bir sayı verilirse sonsuza kadar dönmediğinden emin olmak için ek bir testle klasik özyinelemeli öncelik testi işlevini kullanırız.

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)

Ana sarıcı fonksiyonu:

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

Perl 6 , 45 28 bayt

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

Çevrimiçi deneyin!

yapısını kullanır , bu , bir Rocco numarası olması için asal olmalıdır .$\sqrt{n+49}\pm7$$n$

Açıklama:

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

Normal İfade (ECMAScript), 64 62 bayt

Bu normal ifade, iki ve sayısı bulur . Onları bulursa, veya asal olduğunu varsayar. Bu kadar!$a$$a+14$$n=a(a+14)$$a$$a+14$

Bu, bol sayıdaki regex yazımın bir paragrafında kısaca açıklanan çarpma algoritmasının bir varyantını kullanır . Bu bir spoiler . Bu yüzden , sizin için şımarık bazı gelişmiş tek taraflı regex sihri istemiyorsanız daha fazla okumayın . Bu büyüyü kendiniz anlamaya çalışmak istiyorsanız, bu önceki yazıda arka arkaya spoiler etiketli önerilen problemler listesinde bazı problemleri çözerek ve matematiksel kavrayışları bağımsız olarak bulmaya başlamanızı şiddetle tavsiye ederim .

Çarpma algoritması burada farklı bir şekilde uygulanmaktadır, çünkü birlikte bilinen iki değerin bilinen başka bir değere eşit olduğunu iddia ediyoruz ( bu yazıdaki normal ifadenin alternatif versiyonunda olduğu gibi, bir sayının mükemmel bir kare olduğunu test etmek için). Şimdiye kadar yayınlanan diğer normal ifade cevaplarımın çoğunda, çarpma, hedefin bilinen iki sayının çarpımını bulmak olduğu bir hesaplama (kavramsal olarak değil, bir iddia olarak değil) olarak uygulanır. Her iki yöntem de her iki durumda da çalışır, ancak golf açısından birbirlerinin işini yapmak daha kötüdür.

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

Çevrimiçi deneyin!

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

ṗ;14{+|-};?×

Aday numarasını komut satırı bağımsız değişkeni olarak girin. Çıkışlar trueveya false. Çevrimiçi deneyin!

açıklama

Kod, girdisi sınırlandırılmamış ve çıktısı test ettiğimiz sayı olan bir yüklemdir.

ṗ             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

(İpuçları açıktır. Yani {+|-}hala aksak hissediyor.)

Brachylog , 9 bayt

Daha sonra farklı bir yaklaşım DLosc 'ın cevabı

Ċ-14&∋ṗ&×

N'yi çıktı olarak alır, [P, P-14] veya [P + 14, P] 'yi giriş yoluyla geri verir (önce en büyük sayı)

açıklama

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

Çevrimiçi deneyin!

Pyth, 22 20 bayt

}Qsm*Ld+Ld_B14fP_TSh

Burada çevrimiçi deneyin .

}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

Düzenleme: Giriş olarak kaydedilen 3 bayt her zaman pozitif olacaktır, bu nedenle listeden negatif değerleri filtrelemeye gerek yoktur. Ayrıca girişler için bir hata düzeltildi 1ve 21 bayt maliyeti. Önceki versiyon:}Qsm*Ld>#0+Ld_B14fP_TU

05AB1E , 16 15 14 bayt

1 Bayt 7·yerine 14 bilgisayar tarafından kaydedildi žvÍ(ilk etapta bu düşünmüyordu inanamıyorum).

Emigna sayesinde 1 bayt tasarruf edildi

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

Çevrimiçi deneyin! veya Tüm girişleri test et

açıklama

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

Arnauld'un çözümüne dayanarak :

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

Çevrimiçi deneyin!

Önceki deneme:

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

Çevrimiçi deneyin!

Retina 0.8.2 , 61 bayt

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

Çevrimiçi deneyin! Açıklama:

.+
$*

Tekli'ye dönüştür.

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

\1iki faktörden daha büyük olanını yakalar. \2sabit 14'ü yakalayarak bayt tasarrufu sağlar. \3eksi 1 olmak üzere iki faktörün küçük olanını yakalar. Bu, her iki faktörün de en az 2 olmasını sağlar.

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

Bunlardan en az birinin asal olduğundan emin olmak için iki faktörü kontrol edin. Kullanma fikri \2?@ Deadcode'un cevabından utanmadan çalındı.

(?<-3>\1)+

İki faktörden daha büyük olanını, iki faktörün küçüğünden daha az olana kadar tekrarlayın. Zaten bir kez daha büyük faktörü yakaladığımız için, bu iki faktörün ürününü yakalar.

$(?(3)1)

Ürünün verilen numaraya eşit olduğundan emin olun.

Değiştirerek Retina 1 için doğrudan bir çeviri $*ile *1aynı bayt sayısını olurdu ama bir bayt tüm değiştirerek kaydedilmiş olabilir 1ile s _s ve daha sonra *1yerine kullanılabildiği gibi *yerine *_. Önceki 68 bayt için Retina 1 cevabı:

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

0m`^_{14}$

Çevrimiçi deneyin! Açıklama:

.+
*

Tekli'ye dönüştür.

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

Tüm faktör çiftlerini bulun.

Am` (__+)\1+$

Birinin asal olduğundan emin olun.

(_+) \1

Mutlak farkı ele alalım.

0m`^_{14}$

14 olup olmadığını kontrol edin.

JavaScript (Babel Düğümü) , 69 bayt

Kahretsin, ben Arnaulds'un cevabını yenecektim ama hayır .....: c

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

Çevrimiçi deneyin!

x=>[...Array(x)].some(Özyineleme kullanarak parçadan kurtulmak istiyorum, böylece zamanla kısalır

açıklama

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

Formülü kullanır

Japt , 10 bayt

Javascript Yanıtımla Aynı

k d@/X-X¥E

Çevrimiçi deneyin!

Jöle , 9 bayt

:ạ⁹ɗÆf14e

Çevrimiçi deneyin!

APL (NARS) 16 karakter, 32 bayt

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

{π⍵} argümanının çarpanlarına ayrılmasını bulur ve sonucunun son unsurunun (n'nin bölenleri listesi) n'nin maksimum ana böleni olduğunu varsayarız; Burada, Rocco sayısının eşdeğer bir tanımının: n'nin bir Rocco numarası <=> n = r'nin en yüksek faktör başlangıcı olduğunu varsayalım. / r) Rocco sayısının bu tanımı sonunda 1..1000000 aralığında iyi görünüyor]; ok değeri aralığı 1..maxInt olacaktır; Ölçek:

 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 # Etkileşimli Derleyici) , 99 bayt

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

Çevrimiçi deneyin!

Enumerable.Range tekrar grev :) Çılgın derleyici bayrağını kullanarak, vanilya çözümünün bir hayranı olmama rağmen, işleri biraz azaltabilirsiniz.

C # (Visual C # Etkileşimli Derleyici) + /u:System.Linq.Enumerable, 77 bayt

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

Çevrimiçi deneyin!

Aşağıda Arnauld'un çözümünün oldukça havalı görünen bir limanı var. Şu anda en uzun, ama muhtemelen bazı golf olabilir.

C # (Visual C # Etkileşimli Derleyici) , 101 bayt

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

Çevrimiçi deneyin!

APL (NARS) 30 karakter, 60 bayt

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

Burada 0π, bir sayının asal olup olmadığını söyle fonksiyonudur:

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

F #, 2 cevap (rakipsiz)

@Arnauld'un cevaplarını gerçekten çok beğendim, bu yüzden onları tercüme ettim.

JavaScript yanıtına göre 123 bayt

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

Açıklama:

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

05AB1E yanıtına dayanan 125 bayt

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

Açıklama:

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 bayt

Çıkış koduna göre çıkışlar, 1Rocco numaraları için başarısız ( ).

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

Çevrimiçi deneyin!