Tôi đã được hỏi câu hỏi này trong một cuộc phỏng vấn nhưng tôi không thể tìm ra bất kỳ giải pháp nào. Tôi không biết câu hỏi có đúng hay không. Tôi đã cố gắng rất nhiều nhưng không thể đạt được bất kỳ giải pháp nào. Thành thật mà nói, không có gì đến với tôi.

Số Rocco

Số nguyên dương $n$ là số Rocco nếu nó có thể được biểu diễn dưới dạng $n=p(p+14)$ hoặc $n=p(p-14)$ , trong đó $p$ là số nguyên tố.

10 số Rocco đầu tiên là:

32, 51, 95, 147, 207, 275, 351, 435, 527, 627

$32, 51, 95, 147, 207, 275, 351, 435, 527, 627$

Bài tập

Mã của bạn phải chấp nhận một số nguyên dương làm đầu vào và xác định xem đó có phải là số Rocco hay không.

Điểm Brownie

Viết hàm tính toán và in số đếm số Rocco nhỏ hơn hoặc bằng 1 triệu.
Viết hàm tính toán và in số đếm số Rocco từ câu hỏi phần thưởng (trên một) là số nguyên tố.

code-golf decision-problem number-theory

— vijayscode
nguồn

5

Xin chào và chào mừng đến với PPCG. Chúng tôi tổ chức các thử thách (vẻ ngoài của bạn thực sự thú vị) có tiêu chí ghi điểm và chiến thắng khách quan. Hãy thử chỉnh sửa bài viết của bạn để bao gồm điều đó. Tôi khuyên bạn nên chơi golf-code là mục tiêu, vì đó là cách dễ nhất để làm đúng. Ngoài ra, bạn muốn tránh những phần thưởng đó; chỉ tập trung vào một nhiệm vụ rõ ràng.

— Adám

3

đầu ra sẽ là một số nguyên : Ý bạn không phải là Boolean cho dù đầu vào là số Rocco hay không?

— Adám

5

Phần thưởng 2 : print 0. Tất cả các số Rocco là tổng hợp (n*..), vì vậy không có số nguyên tố trong bất kỳ phạm vi.

— TFeld

4

"Điểm thưởng" đơn giản có thể là các giá trị được mã hóa cứng và hoàn toàn không có lợi cho thử thách. Tôi khuyên bạn nên loại bỏ chúng.

— Erik the Outgolfer

5

Tôi đã chỉnh sửa câu hỏi và các thẻ. Vui lòng quay lại hoặc chỉnh sửa thêm nếu bạn không đồng ý. Như @EriktheOutgolfer đã nói, tôi nghĩ rằng phần thưởng nên được loại bỏ.

— Arnauld

10

05AB1E , 8 byte

Trả về $1$ nếu $n$ là số Rocco hoặc $0$ nếu không.

fDŠ/α14å

Hãy thử trực tuyến!

Làm sao?

Cho một số nguyên dương $n$ , chúng tôi kiểm tra xem có tồn tại một thừa số nguyên tố $p$ của $n$ sao cho:

| p - \frac{n}{p} | = = 14

$\left|p-\frac{n}{p}\right|=14$

Đã bình luậ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

— Arnauld
nguồn

11

JavaScript (ES7), 55 byte

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

Hãy thử trực tuyến!

Làm sao?

Cho một số nguyên dương $n$ , chúng tôi đang tìm một số nguyên tố $x$ sao cho $x(x+14)=n$ hoặc $x(x-14)=n$ .

Do đó các phương trình bậc hai sau:

\begin{matrix} (1) & x^{2} + 14 x - n = = 0 \end{matrix}

$x^2+14x-n=0\tag{1}$

\begin{matrix} (2) & x^{2} - 14 x - n = = 0 \end{matrix}

$x^2-14x-n=0\tag{2}$

Nguồn gốc tích cực của $(1)$ là:

x_{0} = = \sqrt{49 + n} - 7

$x_0=\sqrt{49+n}-7$

và gốc tích cực của $(2)$ là:

x_{1} = = \sqrt{49 + n} + 7

$x_1=\sqrt{49+n}+7$

Do đó, vấn đề tương đương với việc kiểm tra xem $x_0$ hay $x_1$ có phải là số nguyên tố hay không.

Để làm điều đó, chúng tôi sử dụng hàm kiểm tra tính nguyên thủy đệ quy cổ điển, với một thử nghiệm bổ sung để đảm bảo rằng nó không lặp mãi mãi nếu nó đưa ra một số vô tỷ làm đầu vào.

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)

Chức năng bao bọc chính:

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

— Arnauld
nguồn

6

Perl 6 , 45 28 byte

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

Hãy thử trực tuyến!

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

Giải trình:

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

— Jo vua
nguồn

6

Regex (ECMAScript), 64 62 byte

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

Điều này sử dụng một biến thể của thuật toán nhân được mô tả ngắn gọn trong một đoạn của bài đăng regex số phong phú của tôi . Đây là một spoiler . Vì vậy, đừng đọc thêm nữa nếu bạn không muốn một số phép thuật regex unary tiên tiến được làm hỏng cho bạn . Nếu bạn thực sự muốn tự mình tìm ra phép thuật này, tôi khuyên bạn nên bắt đầu bằng cách giải quyết một số vấn đề trong danh sách các vấn đề được đề xuất liên quan đến spoiler trong bài viết trước đó và cố gắng đưa ra những hiểu biết toán học một cách độc lập.

Thuật toán nhân được triển khai khác nhau ở đây vì chúng tôi khẳng định rằng hai giá trị đã biết nhân với nhau bằng một giá trị đã biết khác (cũng được thực hiện trong phiên bản thay thế của biểu thức chính trong bài đăng này , để kiểm tra xem một số có phải là một hình vuông hoàn hảo không). Trong hầu hết các câu trả lời regex được đăng khác của tôi cho đến nay, phép nhân được thực hiện như một phép tính (không phải là khẳng định, nói theo khái niệm) trong đó mục tiêu là tìm ra tích của hai số đã biết. Cả hai phương pháp đều hoạt động trong cả hai trường hợp, nhưng chơi golf khôn ngoan, tệ hơn trong việc thực hiện công việc của nhau.

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

Hãy thử trực tuyến!


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

— Mã chết
nguồn

3

Brachylog , 13 12 byte

ṗ;14{+|-};?×

Nhập số ứng cử viên làm đối số dòng lệnh. Đầu ra truehay false. Hãy thử trực tuyến!

Giải trình

Mã này là một vị từ có đầu vào không bị giới hạn và đầu ra của nó là số chúng tôi đang thử nghiệm.

ṗ             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

(Lời khuyên được chào đón. Điều đó {+|-}vẫn cảm thấy cồng kềnh.)

— DLosc
nguồn

3

Brachylog , 9 byte

Cách tiếp cận khác nhau sau đó câu trả lời của DLosc

Ċ-14&∋ṗ&×

Đưa N làm đầu ra, trả lại [P, P-14] hoặc [P + 14, P] thông qua đầu vào (số lớn nhất trước)

giải trình

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

Hãy thử trực tuyến!

— Kroppeb
nguồn

2

Bình thường, 22 20 byte

}Qsm*Ld+Ld_B14fP_TSh

Hãy thử trực tuyến tại đây .

}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

Chỉnh sửa: Đã lưu 3 byte vì đầu vào sẽ luôn dương, do đó không cần phải lọc ra các giá trị âm từ danh sách. Cũng sửa một lỗi cho đầu vào 1và 2, tốn 1 byte. Phiên bản trước:}Qsm*Ld>#0+Ld_B14fP_TU

— Sok
nguồn

2

05AB1E , 16 15 14 byte

Đã lưu 1 byte bằng cách tính toán 14 7·thay vì žvÍ(không thể tin rằng tôi đã không nghĩ về điều này ngay từ đầu).

Đã lưu 1 byte nhờ Emigna

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

Hãy thử trực tuyến! hoặc Kiểm tra tất cả các đầu vào

Giải trình

                 # 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

— Trí tuệ
nguồn

1

Bạn có thể lưu một byte bằng cách thay đổi }˜såđể Q}Zsử dụng đầu vào ẩn. Test-Suite của bạn sẽ phải được thay đổi một chút thành một cái gì đó như thế này để làm cho nó hoạt động. Ngoài ra, một cách viết rõ ràng hơn žvÍhoặc 7·sẽ là 14;)

— Emigna

Cảm ơn! Tại sao làm cho nó dễ dàng khi bạn có thể đẩy 14 theo cách / facepalm phức tạp nhất :)

— Wisław

2

J , 21 15 byte

Dựa trên giải pháp của Arnauld :

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

Hãy thử trực tuyến!

Khinh thường trước đây:

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

Hãy thử trực tuyến!

— Traws
nguồn

14 e.q:|@-]%q:cho 14 byte

— Jonah

2

Võng mạc 0.8.2 , 61 byte

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

Hãy thử trực tuyến! Giải trình:

.+
$*

Chuyển đổi sang unary.

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

\1nắm bắt lớn hơn của hai yếu tố. \2chụp hằng số 14, tiết kiệm một byte. \3nắm bắt nhỏ hơn trong hai yếu tố, trừ 1. Điều này cũng đảm bảo rằng cả hai yếu tố đều có ít nhất 2.

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

Kiểm tra hai yếu tố để đảm bảo ít nhất một trong số chúng là số nguyên tố. Ý tưởng sử dụng \2?đã bị đánh cắp một cách đáng xấu hổ từ câu trả lời của @ Deadcode.

(?<-3>\1)+

Lặp lại số lớn hơn của hai yếu tố một số lần bằng một nhỏ hơn số nhỏ hơn của hai yếu tố. Vì chúng ta đã nắm bắt được yếu tố lớn hơn một khi điều này kết thúc việc nắm bắt sản phẩm của hai yếu tố.

$(?(3)1)

Đảm bảo rằng sản phẩm bằng số đã cho.

Một bản dịch trực tiếp sang Retina 1 bằng cách thay thế $*bằng *1sẽ có cùng số byte nhưng một byte có thể được lưu bằng cách thay thế tất cả các 1s bằng _s và sau đó *1có thể được thay thế bằng *thay vì *_. Câu trả lời Retina 1 trước cho 68 byte:

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

0m`^_{14}$

Hãy thử trực tuyến! Giải trình:

.+
*

Chuyển đổi sang unary.

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

Tìm tất cả các cặp nhân tố.

Am` (__+)\1+$

Đảm bảo một là chính.

(_+) \1

Lấy sự khác biệt tuyệt đối.

0m`^_{14}$

Kiểm tra xem có bất kỳ 14.

— Neil
nguồn

1

JavaScript (Nút Babel) , 69 byte

Chết tiệt, tôi mặc dù tôi sẽ đánh bại Câu trả lời của Arnaulds nhưng không .....: c

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

Hãy thử trực tuyến!

Tôi muốn thoát khỏi x=>[...Array(x)].some( phần sử dụng đệ quy để nó có thể ngắn hơn theo thời gian

Giải trình

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

Nó sử dụng công thức

n / p - p == 14

$n/p-p==14$

— Luis felipe De jesus Munoz
nguồn

1

Japt , 10 byte

Giống như câu trả lời Javascript của tôi

k d@/X-X¥E

Hãy thử trực tuyến!

— Luis felipe De jesus Munoz
nguồn

1

Thạch , 9 byte

:ạ⁹ɗÆf14e

Hãy thử trực tuyến!

— Erik là người vượt trội
nguồn

1

APL (NARS) 16 ký tự, 32 byte

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

{π⍵} sẽ tìm thấy hệ số của đối số của nó và chúng tôi giả sử rằng phần tử cuối cùng của kết quả của nó (danh sách các ước của n) là ước số nguyên tố tối đa của n; Ở đây, chúng tôi giả sử rằng một định nghĩa tương đương của số Rocco là: n là số Rocco <=> số nguyên tố tối đa của n: r sao cho đúng 14 = ∣rn ÷ r [với C pseudocode là 14 == abs (rn / r) định nghĩa về số Rocco cuối cùng có vẻ ổn trong phạm vi 1..1000000]; phạm vi của giá trị ok sẽ là 1..maxInt; kiểm tra:

 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

— RosLuP
nguồn

1

C # (Trình biên dịch tương tác Visual C #) , 99 byte

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

Hãy thử trực tuyến!

Enumerable.Range đình công một lần nữa :) Sử dụng cờ trình biên dịch điên, bạn có thể giảm bớt mọi thứ một chút, mặc dù tôi là một fan hâm mộ của giải pháp vanilla.

C # (Trình biên dịch tương tác Visual C #) + /u:System.Linq.Enumerable, 77 byte

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

Hãy thử trực tuyến!

Dưới đây là một cổng giải pháp của Arnauld có vẻ khá tuyệt. Nó hiện là dài nhất, nhưng nó có thể được chơi golf một số.

C # (Trình biên dịch tương tác Visual C #) , 101 byte

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

Hãy thử trực tuyến!

— dana
nguồn

0

APL (NARS) 30 ký tự, 60 byte

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

Ở đây 0π là hàm nói nếu một số là số nguyên tố, hãy kiểm tra:

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

— RosLuP
nguồn

0

F #, 2 câu trả lời (không soạn thảo)

Tôi thực sự thích câu trả lời của @Arnauld, vì vậy tôi đã dịch chúng.

123 byte , dựa trên câu trả lời 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(||)

Giải trình:

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 byte , dựa trên câu trả lời 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

Giải trình:

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?

— LSM07
nguồn

0

Con trăn 2 , 58 byte

Đầu ra bằng mã thoát, fail ( 1) cho số Rocco.

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

Hãy thử trực tuyến!

— lò nướng
nguồn

Tìm một số Rocco

Số Rocco

Bài tập

Điểm Brownie

05AB1E , 8 byte

Làm sao?

Đã bình luận

JavaScript (ES7), 55 byte

Làm sao?

Perl 6 , 45 28 byte

Giải trình:

Regex (ECMAScript), 64 62 byte

Brachylog , 13 12 byte

Giải trình

Brachylog , 9 byte

giải trình

Bình thường, 22 20 byte

05AB1E , 16 15 14 byte

Giải trình

J , 21 15 byte

Võng mạc 0.8.2 , 61 byte

JavaScript (Nút Babel) , 69 byte

Japt , 10 byte

Thạch , 9 byte

APL (NARS) 16 ký tự, 32 byte

C # (Trình biên dịch tương tác Visual C #) , 99 byte

C # (Trình biên dịch tương tác Visual C #) + /u:System.Linq.Enumerable, 77 byte

C # (Trình biên dịch tương tác Visual C #) , 101 byte

APL (NARS) 30 ký tự, 60 byte

F #, 2 câu trả lời (không soạn thảo)

Con trăn 2 , 58 byte