인터뷰 에서이 질문을 받았지만 해결책을 찾지 못했습니다. 질문이 옳은지 아닌지 모르겠습니다. 나는 많은 것을 시도했지만 어떤 해결책에도 도달 할 수 없었다. 솔직히 말해서, 내 마음에는 아무것도 없었습니다.

로코 번호

양의 정수 $n$ 은 $n=p(p+14)$ 또는 $n=p(p-14)$ 로 표시 될 수있는 경우 로코 (Rocco ) 번호입니다. 여기서 $p$ 는 소수입니다.

처음 10 개의 로코 번호는 다음과 같습니다.

직무

코드는 양의 정수를 입력으로 받아 들여야하며 Rocco 번호인지 여부를 판별해야합니다.

브라우니 포인트

• 로코 수를 1 백만 이하로 계산하고 인쇄하는 함수를 작성하십시오.
• 소수의 보너스 질문 (위의 위)에서 로코 수를 계산하고 인쇄하는 함수를 작성하십시오.

05AB1E , 8 바이트

반환 $1$ 경우 $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

자바 스크립트 (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$

따라서 다음 2 차 방정식 :

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

펄 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$

이것은 내 풍부한 숫자 정규 표현식 post 단락에 간략하게 설명 된 곱셈 알고리즘의 변형을 사용합니다 . 이것은이다 스포일러 . 따라서 고급 단항 정규식 마술을 원하지 않는다면 더 이상 읽지 마십시오 . 이 마법을 스스로 알아내는 데 총력을 기울이려면 이 이전 게시물 의 연속 스포일러 태그 권장 문제 목록에서 몇 가지 문제를 해결 하고 수학 통찰력을 독립적으로 생각해 보는 것이 좋습니다 .

곱셈 알고리즘은 여기에서 다르게 구현됩니다. 우리는 두 개의 알려진 값이 다른 알려진 값과 같이 곱했다고 주장하기 때문에 ( 이 게시물 의 정규식 대체 버전에서와 같이 숫자가 완벽한 제곱인지 테스트하기 위해). 지금까지 게시 된 다른 정규식 답변의 대부분에서 곱셈은 두 개의 알려진 숫자의 곱을 찾는 것이 목표 인 개념 (어설 션이 아닌 주장으로 계산)으로 구현됩니다. 두 가지 방법 모두 두 가지 상황에서 모두 작동하지만 골프 방식은 서로의 업무 수행이 더 나쁩니다.

^(?=(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및 21 바이트 비용 버그가 수정되었습니다 . 이전 버전:}Qsm*Ld>#0+Ld_B14fP_TU

05AB1E , 16 15 14 바이트

7·대신 14를 계산하여 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)

제품이 주어진 숫자와 같은지 확인하십시오.

교체하여 망막 1로 직접 번역 $*으로는 *1같은 바이트 수있을 것입니다하지만 바이트는 모든 대체하여 저장 될 수 1로들 _의 후가 *1로 대체 될 수 *보다는 *_. 68 바이트에 대한 이전 Retina 1 답변 :

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

0m`^_{14}$

온라인으로 사용해보십시오! 설명:

.+
*

단항으로 변환합니다.

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

모든 요인 쌍을 찾습니다.

Am` (__+)\1+$

하나가 소수인지 확인하십시오.

(_+) \1

절대 차이를 취하십시오.

0m`^_{14}$

14가 있는지 확인하십시오.

JavaScript (바벨 노드) , 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 바이트

내 자바 스크립트 답변 과 동일

k d@/X-X¥E

온라인으로 사용해보십시오!

젤리 , 9 바이트

:ạ⁹ɗÆf14e

온라인으로 사용해보십시오!

APL (NARS) 16 자, 32 바이트

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

{π⍵}는 인수의 인수 분해를 발견하고 그 결과의 마지막 요소 (제수의 제수 목록)가 최대 소수의 제수 n이라고 가정합니다. 여기서 우리는 로코 (Rocco) 수의 하나의 동등한 정의가 다음과 같다고 가정한다 : n은 로코 (Rocco) 수 <=> 최대 인자 소수 n : 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 # Interactive Compiler) , 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 strikes again :) 미친 컴파일러 플래그를 사용하면 바닐라 솔루션의 팬이지만 일을 상당히 줄일 수 있습니다.

C # (Visual C # Interactive Compiler) + /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 # Interactive Compiler) , 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의 답변이 정말 마음에 들었습니다.

JavaScript 응답을 기반으로 한 123 바이트

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

05AB1E 답변을 기반으로 한 125 바이트

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?

파이썬 2 , 58 바이트

종료 코드에 의한 출력, 1Rocco 번호의 경우 실패 ( ).

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

온라인으로 사용해보십시오!