연속적인 프라임 / 일정한 지수입니까?


22

얼마 전에 저는 27000의 소인수 분해를 살펴 보았습니다.

27000 = 2 3 × 3 3 × 5 3

그것에 대해 두 가지 특별한 점이 있습니다.

  • 연속 프라임 : 소수는 연속적입니다. 2는 첫 번째 소수, 3은 두 번째 소수, 5는 세 번째 소수입니다.
  • 상수 지수 : 지수는 모든 소수에 대해 동일합니다 (항상 3).

수학적으로 표현 :

x = p n m × p n +1 m × ... × p n + k m 과 같이 양의 정수 n , k , m 이 존재하는 경우 정수 x 는 연속 소수 / 상수 지수입니다 . 여기서 p jj 번째 소수입니다

당신의 임무는 양의 정수가 이러한 조건을 충족하는지 테스트하는 것입니다.

입력:

모든 합리적인 형식의 양의 정수> 1

산출:

입력 값이 연속적인 프라임 / 정수 지수인지 여부를 나타내는 두 값 중 하나 이상이 일정해야합니다.

에지 케이스 :

  • 소수 p 의 인수 분해 가 p 이므로 소수는 진실 입니다 1
  • 과 같이 쓸 수있다 다른 숫자 P는 m p가 소수 인도 truthy 있습니다.

규칙 :

  • 표준 허점이 적용됩니다.
  • 정수 오버플로에 대해 걱정할 필요는 없지만 255까지의 숫자가 작동해야합니다.
  • 바이트 단위의 최단 코드가 이깁니다.

테스트 사례 :

진실한 :

2
3
4
5
6
7
8
9
11
13
15
27000
456533

거짓 :

10
12
14
72
10000000

다음 은 몇 가지 테스트 사례를 생성하는 Python 스크립트입니다.

내가 대답을 받아 들였다고해서 도전이 끝났다는 의미는 아닙니다. 승자는 여전히 바뀔 수 있습니다!


이러한 모든 숫자의 목록을 생성하고 입력이 목록에 있는지 확인하여 다른 방법으로이 작업을 수행 할 수 있습니다.
엔지니어 토스트

@EngineerToast 그래도 많은 숫자가 있습니다.
Alexis Olson

@AlexisOlson 물론, 여러 언어에서 정수로 처리 할 수있는 유한 요소입니다.
엔지니어 토스트

당신의 수학적 표현에는 Pj가 그 x = Pn^m부분 과 관련이 없습니다 . 나는 당신이 Pn이 n 번째 프라임을 의미한다고 가정합니다
Veskah

@Veskah n 은 특정 값 (첫 번째 소수를 x로 나누는 인덱스 )을 가지므로 Pn + 1n + 1 번째 소수 임을 암시하려면 Pnn 번째 소수 라고 말하는 것이 어색합니다 .
Dennis

답변:



7

정규식 (ECMAScript를) 276 205 201 193 189 바이트

ECMAScript 정규식을 사용하여 여러 주요 요소의 다중성 (지수)을 비교하는 것은 흥미로운 문제입니다. 루프의 반복을 통해 지속되는 역 참조가 없기 때문에 모든 것을 계산하기가 어렵습니다. 문제의 수치 적 특성을 세는 것이 가능하더라도,보다 간접적 인 접근은 종종 더 나은 골프를 만듭니다.

다른 ECMA 정규식 게시물과 마찬가지로 스포일러 경고를 제공합니다 . ECMAScript 정규식에서 단항 수학 문제를 해결하는 방법을 배우는 것이 좋습니다. 그것은 나를위한 매혹적인 여정이었습니다. 저는 스스로 그것을 시도하고 싶을 수도있는 사람, 특히 수 이론에 관심이있는 사람들을 위해 그것을 망치고 싶지 않습니다. 스포일러 태그가 붙은 권장 문제를 하나씩 해결하기위한 연속적인 문제 목록은 이 게시물참조하십시오 .

따라서 고급 단항 정규식 마법을 원하지 않는다면 더 이상 읽지 마십시오 . 이 마법을 스스로 파악하는 데 총력을 기울이고 싶다면 위에 링크 된 게시물에 요약 된 ECMAScript 정규식의 일부 문제를 해결하는 것이 좋습니다.

이전에 개발 한 정규식의 주요 페이로드는이 과제에 매우 적합하다는 것이 밝혀졌습니다. 그것이 가장 높은 다중성의 소수를 찾는 정규 표현식입니다 . 그에 대한 나의 첫 번째 솔루션은 매우 긴, 그리고 나중에 첫째, 방법은 아래 단계에서 그것을 golfed 분자 내다를 사용하도록 다시 작성 후, 그리고 다시 일반 인 ECMAScript에 포팅 에 고급 기술을 사용하여 분자 내다 부족 해결 , 이후 원래의 일반 ECMAScript 솔루션보다 훨씬 작게 골라냅니다.

이 문제에 적용되는 정규 표현식의 일부는 첫 번째 단계이며, 모든 주요 요소를 공유하는 N의 가장 작은 요소 인 Q를 찾습니다. 일단이 숫자를 가지면, N이 "일정한 지수"임을 나타 내기 위해해야 ​​할 일은 더 이상 할 수 없을 때까지 N을 Q로 나누는 것입니다. 결과가 1이면 모든 소수가 동일한 다중성입니다.

(내와 동일한 알고리즘을 사용하여 N의 가장 큰 사각없는 요소 찾기 : Q를 찾아 내 이전에 개발 된 알고리즘을 사용하여 답변을 제출 한 후, 나는 그것이 완전히 다른 방식으로 계산 될 수 있음을 깨달았다 카 마이클 번호 정규식 ). 결과적으로, 이것은 분자 표현 부족과 가변 길이 비하인드 (이전에 사용 된 고급 기술을 끌어들일 필요가 없음)를 밟는 데 전혀 어려움이 없으며 * 64 바이트 더 짧습니다! 또한이 솔루션에서 사각없는 N과 소수 N을 다른 특수한 경우로 처리하는 복잡성을 제거하여이 솔루션에서 7 바이트를 더 떨어 뜨립니다.

(여전에는 Q 계산을 내리기 위해 이전에 사용했던 고급 기술이 필요한 다른 문제가 여전히 있지만 현재 PPCG 게시물로 표시되는 문제는 없습니다.)

나는 다중성 테스트를 연속 프라임 테스트 전에 두었다. 왜냐하면 후자는 훨씬 느리기 때문이다. 더 빨리 실패 할 수있는 테스트를 먼저 배치하면 정규 분산 입력에 대한 정규식이 더 빨라집니다. 더 많은 역 참조를 사용하기 때문에 먼저 두 번째 숫자를 사용하면 비용이 더 많이 들기 때문에 골프를 우선으로하는 것이 좋습니다.

몫이 제수보다 크거나 같은 경우 Grimy 가 찾은 트릭을 사용 하여이 정규식 (193 → 189)에서 4 바이트를 삭제할 수있었습니다 .

^(?=(|(x+)\2*(?=\2$))((?=(xx+?)\4*$)(?=(x+)(\5+$))\6(?!\4*$))*x$)(?=.*$\2|((?=((x*)(?=\2\9+$)x)(\8*$))\10)*x$)(?!(((x+)(?=\13+$)(x+))(?!\12+$)(x+))\11*(?=\11$)(?!(\15\14?)?((xx+)\18+|x?)$))

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

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \2.
# If N is square-free, \2 will be unset.
(?=
    # Search through all factors of N, from largest to smallest, searching for one that
    # satisfies the desired property. The first factor tried will be N itself, for which
    # \2 will be unset.
    (|(x+)\2*(?=\2$))     # for factors < N: \2 = factor of N; tail = \2
    # Assert that tail is square-free (its prime factors all have single multiplicity)
    (
        (?=(xx+?)\4*$)    # \4 = smallest prime factor of tail
        (?=(x+)(\5+$))    # \5 = tail / \4 (implicitly); \6 = tool to make tail = \5
        \6                # tail = \5
        (?!\4*$)          # Assert that tail is no longer divisible by \4, i.e. that that
                          # prime factor was of exactly single multiplicity.
    )*x$
)
# Step 2: Require that either \2 is unset, or that the result of repeatedly
# dividing tail by \2 is 1.
(?=
    .*$\2
|
    (
        # In the following division calculation, we can skip the test for divisibility
        # by \2-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
        # capture \2-1 above, and can use a better-golfed form of the division.
        (?=
            (              # \8 = tail / \2
                (x*)       # \9 = \8-1
                (?=\2\9+$)
                x
            )
            (\8*$)         # \10 = tool to make tail = \8
        )
        \10               # tail = \8
    )*
    x$                    # Require that the end result is 1
)

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
(?!
    (                          # \11 = a factor of N
        (                      # \12 = a non-factor of N between \11 and \13
            (x+)(?=\13+$)      # \13 = a factor of N smaller than \11
            (x+)               # \14 = tool (with \15) to make tail = \13
        )
        (?!\12+$)
        (x+)                   # \15 = tool to make tail = \12
    )
    \11*(?=\11$)               # tail = \11

    # Assert that \11, \12, and \13 are all prime
    (?!
        (\15\14?)?             # tail = either \11, \12, or \13
        ((xx+)\18+|x?)$
    )
)


* 분자의 선견지명으로 여전히 깨끗하며 N의 경우 사각이 없습니다. 6 바이트가 줄어들어 195187 183 바이트 솔루션이 생성됩니다.

^(?=(?*(x+))\1*(?=\1$)((?=(xx+?)\3*$)(?=(x+)(\4+$))\5(?!\3*$))*x$)(?=((?=((x*)(?=\1\8+$)x)(\7*$))\9)*x$)(?!(((x+)(?=\12+$)(x+))(?!\11+$)(x+))\10*(?=\10$)(?!(\14\13?)?((xx+)\17+|x?)$))

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \1.
(?=
    (?*(x+))              # \1 = proposed factor of N
    \1*(?=\1$)            # Assert that \1 is a factor of N; tail = \1
    # Assert that tail is square-free (its prime factors all have single multiplicity)
    (
        (?=(xx+?)\3*$)    # \3 = smallest prime factor of tail
        (?=(x+)(\4+$))    # \4 = tail / \3 (implicitly); \5 = tool to make tail = \4
        \5                # tail = \4
        (?!\3*$)          # Assert that tail is no longer divisible by \3, i.e. that that
                          # prime factor was of exactly single multiplicity.
    )*x$
)
# Step 2: Require that the result of repeatedly dividing tail by \1 is 1.
(?=
    (
        # In the following division calculation, we can skip the test for divisibility
        # by \1-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
        # capture \1-1 above, and can use a better-golfed form of the division.
        (?=
            (             # \7 = tail / \1
                (x*)      # \8 = \7-1
                (?=\1\8+$)
                x
            )
            (\7*$)        # \9 = tool to make tail = \7
        )
        \9                # tail = \7
    )*
    x$                    # Require that the end result is 1
)

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
(?!
    (                          # \10 = a factor of N
        (                      # \11 = a non-factor of N between \10 and \12
            (x+)(?=\12+$)      # \12 = a factor of N smaller than \10
            (x+)               # \13 = tool (with \14) to make tail = \12
        )
        (?!\11+$)
        (x+)                   # \14 = tool to make tail = \11
    )
    \10*(?=\10$)               # tail = \10

    # Assert that \10, \11, and \12 are all prime
    (?!
        (\14\13?)?             # tail = either \10, \11, or \12
        ((xx+)\17+|x?)$
    )
)

여기에 가변 길이 lookbehind로 포팅됩니다.

정규식 (ECMAScript를 2,018) 198 195 194 186 182 바이트

^(?=(x+)(?=\1*$)(?<=^x((?<!^\5*)\3(?<=(^\4+)(x+))(?<=^\5*(x+?x)))*))((?=((x*)(?=\1\8+$)x)(\7*$))\9)*x$(?<!(?!(\14\16?)?((xx+)\12+|x?)$)(?<=^\13+)((x+)(?<!^\15+)((x+)(?<=^\17+)(x+))))

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

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \1.
(?=
    (x+)(?=\1*$)      # \1 = factor of N; head = \1
    (?<=              # This is evaluated right-to-left, so please read bottom to top.
        ^x
        (
            (?<!^\5*)        # Assert that head is no longer divisible by \6, i.e. that
                             # that prime factor was of exactly single multiplicity.
            \3               # head = \4
            (?<=(^\4+)(x+))  # \4 = head / \5 (implicitly); \3 = tool to make head = \4
            (?<=^\5*(x+?x))  # \5 = smallest prime factor of head
        )*
    )
)
# Step 2: Require that the result of repeatedly dividing tail by \1 is 1.
(
    # In the following division calculation, we can skip the test for divisibility
    # by \1-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
    # capture \1-1 above, and can use a better-golfed form of the division.
    (?=
        (             # \7 = tail / \1
            (x*)      # \8 = \7-1
            (?=\1\8+$)
            x
        )
        (\7*$)        # \9 = tool to make tail = \7
    )
    \9                # tail = \7
)*
x$                    # Require that the end result is 1

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
# This is evaluated right-to-left, so please read bottom to top, but switch back to
# reading top to bottom at the negative lookahead.
(?<!
    # Assert that \13, \15, and \17 are all prime.
    (?!
        (\14\16?)?           # tail = either \13, \15, or \17
        ((xx+)\12+|x?)$
    )

    (?<=^\13+)
    (                        # tail = \13
        (x+)                 # \14 = tool to make tail = \15
        (?<!^\15+)
        (
            (x+)             # \16 = tool (with \14) to make tail = \17
            (?<=^\17+)(x+)   # \17 = a factor of N smaller than \13
        )                    # \15 = a non-factor of N between \13 and \17
    )                        # \13 = a factor of N
)

당신은 대체 할 수 .*$\2\2^
H.PWiz

비록 이것이 유효하다고 생각합니다 :^(?=(|(x+)\2*(?=\2$))(((?=(xx+?)\5*$)(?=(x+)(\6+$))\7(?!\5*$))*x$))(?!(((xx+)(?=\10+$)(x+))(?!\9+$)(x+))\8*(?=\8$)(?!(\12\11?)?(xx+)\14+$))((?=((x*)(?=\2\17+$)x)(\16*$))\19)*\3$
H.PWiz

그래도 최적에 가깝지는 않습니다
H.PWiz

6

젤리 , 13 6 5 바이트

ÆEt0E

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

여전히 outgolfed ... (-1 바이트 에릭에게 감사합니다)


설명

ÆE     # get a list of prime exponents (noooo long builtin name)
  t0   # remove zeroes on both sides (leading or trailing)
    E  # all remaining elements are equal

œl-> t. ÆE의 출력에 후행 0이 존재하는 이유는 없습니다.
Outgolfer Erik


@dylnan 2250에 실패합니다 .
Dennis

@Dennis 덕분에, 나는 그것이 작동하지 않을 깨달았다 그러나 나는 네 바이트 솔루션을 영감 바라고
dylnan

6

JavaScript (ES6), 87 바이트

반환 0 truthy 또는 falsy 0이 아닌 정수.

f=(n,k=2,j,i)=>n%k?j*(P=d=>k%--d?P(d):d==!i)(k)|j-i|(n>1&&f(n,k+1,j||i)):f(n/k,k,j,-~i)

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

댓글

f = (                     // f() = recursive function taking:
  n,                      //   n = input
  k = 2,                  //   k = current factor
  j,                      //   j = reference exponent, initially undefined
  i                       //   i = current exponent, undefined each time we start testing
) =>                      //       the next factor
  n % k ?                 // if k is not a divisor of n:
    j * (                 //   ignore the primality of k if j is still undefined
      P = d =>            //     P() = function testing if k is prime:
        k % --d ?         //       decrement d; if d is not a divisor of k:
          P(d)            //         do a recursive call until it is
        :                 //       else:
          d == !i         //         unless i is already defined: d must not be equal to 1
                          //         (if it is: k is the next prime but does not divide n)
    )(k) |                //   initial call to P() with d = k
    j - i | (             //   if both i and j are defined, they must be equal
      n > 1 &&            //   if n is not yet equal to 1,
      f(n, k + 1, j || i) //   go on with k + 1; if j is undefined, set it to i
    )                     //   (otherwise, stop recursion and return what we have)
  :                       // else:
    f(n / k, k, j, -~i)   //   increment the current exponent and go on with n / k

의 변경으로 인해이 문제가 해결 j||i되었습니다 i. 이제 많은 오 탐지가 발생합니다.
데드 코드

@Deadcode 현재로서는 이것을 확인하거나 수정할 수 없으므로 지금 롤백했습니다.
Arnauld

5

CJam , 30 29 바이트

{mFz~)-!\__W=,\0=>\-:mp1#W=&}

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

거의 2 (!) 년 휴식을 취한 후의 첫 번째 대답은 아마도 더 많은 골프를 타는 것입니다. 이것은 입력을 정수로 취하는 블록입니다 (정수 배열에도 맵핑 될 수 있음).

설명

{        e# Begin block
 mF      e# Factor input, giving an array of primes and their powers
 z~      e# Transpose and dump, giving an array of primes and an array of powers
 )-      e# Check that the powers are the same: subtract each power from the last element
 !       e# Negate to make sure they're all 0
 \__W=,  e# Get the range from 0 to the largest prime minus one
 \0=>    e# Slice that array so it only includes everything larger than the smallest prime
 \-      e# Remove the original primes from the range array
 :mp     e# Check each element for primality. If the input's primes are consecutive,
         e# this will contain no primes
 1#W=    e# Make sure a "1" is not found
 &       e# If the powers are the same AND primes are consecutive, return 1. Otherwise, 0.
}

5

Stax , 5 6 바이트

╣♥qJ╬c

실행 및 디버깅

포장을 풀고 포장을 풀고 주석을 달았습니다.

|n    get the exponents of the prime factorization
0:D   trim leading zeroes
:u    array has exactly a single distinct element

편집 : 작동하지 않습니다 512. 나는 그것에 대해 약간의 생각과 희망을 갖고 나중에 고칠 것이다. 지금 작동합니다.


3

Stax , 9 바이트

1은 진실, 0은 거짓

αAG<└\{┬⌠

실행 및 디버깅

설명

|nX0-u%x:^=      # Full Program, unpacked, implicit input
|n               # Exponents of sequential primes in factorization. (eg. 20 -> [2 0 1])
  X              # Save to X register
   0-            # Remove all '0' from array
     u%          # Get unique numbers and get length of array
       x         # Copy back the array saved to X
        :^       # Is it ascending
         =       # Are the two comparisons equal? implicit output

아마도 더 골프를 칠 수는 있지만 마지막 솔루션에서 누락 된 경우를 다룹니다.


3

MATL , 12 11 10 바이트

YFtgYsg)Zs

MATL Online에서 사용해보십시오!

remove-leading-zeroes 부분에 대해 Luis Mendo에게 감사드립니다. 또한 진리 값 교환이 허용되므로 도전 요구 사항을 만족하는 숫자에 대해서는 0 을 , 그렇지 않으면 양수 값에 대해서는 0 을 반환합니다 .

Grosso Modo는 순차적 소수 인수 분해의 지수를 생성하고 선행 0을 제거하고 표준 편차를 계산합니다.


0iYFhdz7 바이트에서 작동 한다고 생각 합니다. 순차 인수 분해, 연속 차이, 0이 아닌 수의 지수에 0을 추가하십시오. 1입력이 요구 사항을 만족하면 결과가 나타납니다.
Luis Mendo

@LuisMendo 지연된 답변에 대해 죄송하지만 별도의 답변으로 게시 할 수 있습니다. 가장 확실히 다릅니다.
Mr. Xcoder

좋아요, 답변으로 게시했습니다
Luis Mendo

3

자바 10 223 191 178 176 168 바이트

n->{var s=new java.util.HashSet();for(int f=1,i=1,x,j;n>1;){for(x=++i,j=2;j<x;)x=x%j++<1?1:x;if(x>1){for(j=0;n%i<1&&n>(f=0);n/=i)j++;if(f<1)s.add(j);}}return s.size();}

1진실하고 거짓으로 반환합니다 >=2.

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

설명:

n->{                   // Method with integer parameter and boolean return-type
  var s=new java.util.HashSet();
                       //  Set to keep track of the prime exponents
  for(int f=1,         //  Prime-flag, starting at 1
          i=1,x,j;     //  Index and temp integers
          n>1;){       //  Loop as long as `n` is still larger than 1
    for(x=++i,         //   Set `x` to `i`, after we've increased `i` by 1 first with `++i`
        j=2;           //   Set `j` to 2 (first prime)
        j<x;)          //   Inner loop as long as `j` is still smaller than `x`
      x=x%j++<1?       //    If `x` is divisible by `j`:
         1             //     Set `x` to 1
        :              //    Else:
         x;            //     Leave `x` unchanged
    if(x>1){           //    If `x` is larger than 1 (if `i` is a prime):
      for(j=0;         //     Use `j` as counter, and set it to 0
          n%i<1        //     If `n` is divisible by `i`:
                       //      And loop as long as `n` is still divisible by `i`,
          &&n>         //      and `n` is larger than 0
              (f=0);   //      (and set `f` to 0 at the same time)
          n/=i)        //       Divide `n` by `i`
        j++;           //       And increase `j` by 1
      if(f<1)          //     If the flag `f` is now/still 0:
        s.add(j);}}    //      Add counter `j` to the Set
  return s.size();}    //  Return the amount of items in the Set
                       //  (1 being true, >=2 being false)

일부 입력 예 :

n=15:

  • 플래그는 1첫 번째 소수 2로 남아 있습니다 (15는 2로 나눌 수 없기 때문에).
  • 국기에서 진행 10빨리 우리가 15 년 이후 주요 3에있는 한 3으로 나누어, n5 (15/3된다 1 ), 및 설정이된다 [] → [1].
  • 그런 다음 다음 프라임 5를 확인합니다. 5는 5로 나눌 수 있으므로 n1 (5/5 1 )이되고 세트는 동일하게 유지됩니다 ( [1] → [1]).
  • 이제 n=1외부 루프를 중단합니다. Set ( [1])에는 1인접한 소수 3과 5에서 하나의 항목 만 포함 되므로 true를 반환합니다.

n=14:

  • 첫 번째 소수 2 10대해 플래그가 이동합니다 (14는 2로 나눌 수 있기 때문에). n는 7 (14/2 1 )이되고 세트 는가 됩니다 [] → [1].
  • 그런 다음 다음 소수 3을 확인합니다. 7은 3으로 나눌 수 없으므로 n동일하게 유지되며 세트는가됩니다 [1] → [1,0].
  • 그런 다음 다음 프라임 5를 확인합니다. 7도 5로 나눌 수 없으므로 n동일하게 유지되며 세트도 동일하게 유지됩니다 ( [1,0] → [1,0]).
  • 7은 7로 나눌 수 있으므로 n1은 1 (7/7 1 )이되고 세트는 그대로 유지됩니다 ( [1,0] → [1,0]).
  • 이제 n=1외부 루프를 중단합니다. Set ( [1,0])에는 1인접하지 않은 프라임 2와 7과 0프라임 3과 5의 두 항목이 포함되어 있으므로 false를 반환합니다.

n=72:

  • 72는 2로 나눌 수 있기 때문에 첫 번째 소수 2 10대해 플래그가 이동 합니다. 따라서 n9 (72/2 3 )가되고 세트 는가 됩니다 [] → [3].
  • 그런 다음 다음 소수 3을 확인합니다. 9는 3 (다중)으로 나눌 수 있으므로 n1 (9/3 2 )이되고 Set 은가 됩니다 [3] → [3,2].
  • 이제 n=1외부 루프를 중단합니다. Set ( [3,2])은 3from prime 2와 2from prime 3의 두 항목을 포함 하므로 false를 반환합니다.

1
<2int를 제거 하고 반환 할 수 있습니다 (진실한 경우 1을 반환하도록 지정하십시오).
wastl

@wastl 아, 두 값 중 하나만 일치한다는 규칙을 놓쳤습니다. 이 경우 1에는 진실되고 2그 이상은 거짓입니다. 감사.
Kevin Cruijssen

현상금을 준 사람 덕분에 왜?
Kevin Cruijssen

1
ECMAScript 답변에 더 많은 관심을 끌기 위해 "기존 답변에 대한 보상"현상금을 시작했습니다. 그 주가 끝났을 때, 나는 현상금을 수여하기 위해 내 자신의 대답 이외의 답변을 선택하거나 그것을 최고 투표로 채무 불이행으로 두어야했습니다. 나는 그만한 가치가 있다고 생각하지 않았지만, 당신의 대답은 가장 잘 설명되어 있으며, 이것이 내가 당신에게 그것을 준 이유입니다. 좋은 설명은 PPCG에서 너무 드물다. 내 대답에 관해서는, 나는 더 나은 글씨를 써야한다고 생각합니다. 시간이있을 때 계획합니다.
데드 코드

1
@Deadcode 아, 그래서 이유입니다. 나는 누군가가 현상금을 시작했다고 생각했지만 실수로 만료되도록하고 대신 나에게 왔습니다. 여전히 내 대답이 왜 가장 높은 투표가 아닌지 약간 혼란 스럽습니다. 모든 정규식 답변에 감동합니다. 나는 그들 중 일부를 보았고 놀랄 때마다. 특히 나중에 같은 대답으로 돌아와서 골프를 치면 더 많이로드됩니다. : DI는 방금이 도전에 대한 내용을 보거나 찬성하지 않았다는 것을 알아 차 렸습니다. 이 답변에 현상금을 추가하겠습니다 . :)
Kevin Cruijssen

2

J , 16 바이트

-8 바이트의 FrownyFrog에 큰 감사를드립니다!

(=&#+/\=@#])_&q:

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

내 오래된 해결책 :

J , 24 바이트

[:(1=[:#@~.{.@I.}.])_&q:

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

설명:

_&q: 주요 지수

{.@I.}.] 0이 아닌 첫 번째 요소를 찾아서 선행 0을 제거합니다.

     }.   drop
       ]  from the list of exponents
{.@       as much items as the first of the 
   I.     indices of non-zero elements

1=[:#@~. 나머지 모든 숫자가 같은지 테스트합니다.

  [:#@~.  finds the length of the list after removing the duplicates
1=        is it 1?



2

옥타브 , 67 바이트

@(x)~any(diff(find(h=histc(factor(x),primes(x))))-1)&h(h>0)==max(h)

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

히스토그램을 사용하는 유일한 솔루션이라고 생각합니다.

설명:

그러면 계산할 변수가 입력의 요인 인 bins에 배치되는 히스토그램이 만들어집니다.이 값 primes(x)은 모두 입력 값보다 소수입니다. 그런 다음 주요 요인의 위치를 ​​찾아 각 지수의 차이를 빼고 빼냅니다. 0이 아닌 요소가있는 경우 (즉, 소수의 지수 차이가 1이 아닌 경우) 잘못된 값이 발생하고 그렇지 않은 경우 진실한 값을 반환합니다.

그런 다음 히스토그램의 0이 아닌 모든 요소가 최대 요소와 동일하다는 것을 확인합니다. 같지 않은 값이 있으면 잘못된 값이되며 그렇지 않은 경우 진실한 값이 반환됩니다.

두 블록이 모두 진실이라면 입력은 연속적인 소수 상수 지수입니다!


1

APL (Dyalog Extended) , 28 바이트

{f p`↓⍭⍵⋄(1=≢∪p)∧∨/f⍷⍸1⍭⍳⍵}

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

방법:

{f p`↓⍭⍵⋄(1=≢∪p)∧∨/f⍷⍸1⍭⍳⍵} ⍝ Monadic function, takes an argument ⍵
       ⍭⍵                     ⍝ Prime factors and exponents of ⍵
     `                         split the resulting matrix in 2 vectors
 f p                           assign the factors to f and the powers to p
                               then
                          ⍳⍵    range [1..⍵]
                        1      primality check for each element in the vector
                                where; returns the indices of truthy values
                     f          find the factors; returns a boolean vector
                   ∨/            logical OR reduction
                                logical AND
           (   p)               unique members of the powers
                                tally; returns the number of elements in the vector
            1=                   check if there's only one element




0

클린 , 127 바이트

import StdEnv
@n=[]== $n
?n#j= $n
= @n||j==filter@[hd j..last j]&&any(\p=(prod j)^p==n)[1..n]
$n=[i\\i<-[2..n-1]|n/i*i==n&& @i]

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

우선 순위 를 분해하고 확인 ? :: Int -> Bool하는 $ :: Int -> [Int]데 사용 하는 함수 를 정의합니다 @ :: Int -> Bool.


0

APL (NARS) 41 자, 82 바이트

{(1=≢∪+/¨{v=⍵⊃v}¨⍳≢v)∧(1↓w)≡¯1↓1πw←∪v←π⍵}

{π⍵}는 소인수 목록에서 인수 ⍵의 함수 인수 분해입니다 (한 소수의 소수가 더 많은 시간이 나타나면 반복).
{1π⍵}는 다음 소수입니다 (이 경우 인수는 스칼라가 아니라 하나의 정수 배열 임). 테스트:

  h←{(1=≢∪+/¨{v=⍵⊃v}¨⍳≢v)∧(1↓w)≡¯1↓1πw←∪v←π⍵}
  (2..30)/⍨h¨2..30
2 3 4 5 6 7 8 9 11 13 15 16 17 19 23 25 27 29 30 
  h¨27000 456533 72 10000000
1 1 0 0 
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.