_{( 채팅을 통해 )}

OEIS 항목 A123321 에는 7 개의 소수로 구성된 일련의 숫자가 나열되어 있습니다. 간결하게하기 위해이 번호를 7DP 번호라고합니다. 처음 몇 숫자와 해당 제수는 다음과 같습니다.

510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19

여기서의 과제는 주어진 입력에서 절대 거리 측면에서 가장 가까운 7DP 번호를 찾는 것입니다.

입력

하나의 양의 정수 n은 임의의 편리한 형식 .

산출

편리한 형식으로 다시 n에 가장 가까운 7DP 번호 . 두 개의 7DP 번호가 가장 근접하게 연결되어 있으면 둘 중 하나 또는 둘 다를 출력 할 수 있습니다.

규칙

• 숫자는 언어의 기본 [int]데이터 유형 (또는 이에 상응하는 형식) 에 맞는 것으로 가정 할 수 있습니다 .
• 전체 프로그램 또는 기능이 허용됩니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 code-golf 이므로 일반적인 모든 골프 규칙이 적용되며 가장 짧은 코드가 승리합니다.

예

5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)

파이썬, 89 86 85 바이트

f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n

알고리즘은 O (무서운) 이며 재귀는 실제로 도움이되지 않지만 가능한 한 잘 작동합니다. n 이 7DP 숫자에 충분히 가까운 한 .

3 바이트를 골라 낸 @xnor에게 감사드립니다!

그것을 테스트 repl.it에서 .

작동 원리

파이썬에는 우선 순위 나 인수 분해 기능이 내장되어 있지 않지만, 제수의 양과 특성으로 7DP 숫자를 식별 할 수 있습니다.

곱셈 원리에 의해, 정수의 제수의 수는 소인수 분해의 증분 된 지수의 곱으로 계산 될 수 있습니다. 따라서, σ ₀ (N) ( 제수 기능 )은 2 ^m 마다 N MDP 번호이다.

따라서 σ ₀ (n) = 128 은 필요한 조건이지만 충분하지는 않습니다. 예를 들어, σ ₀ (2 ¹²⁷ ) = 128 이지만 2 ¹²⁷ 은 분명히 7DP 숫자가 아닙니다. 그러나 σ ₀ (n) = 128 이고 완전한 제곱이 n을 균등하게 나누지 않으면 n 나누지 않으면 은 7DP 수입니다.

입력 n의 경우, 알고리즘은 정수 n , n-1 , n + 1 , n-2 , n + 2 등을 검사하고 7DP 숫자 인 첫 번째 것을 반환하는 것으로 구성됩니다.

때 F가 인수로 호출 N , 다음과 같은 상황이 발생합니다

• 코드

  126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))

  다음과 같이 n 이 7DP 번호 가 아닌지 테스트 합니다.

  모든 정수를 들어 내가 있도록 1 <나는 <N , 1>>n%i<<7*(n/i%i<1)평가됩니다.

  • 경우 n은 로 나누어 내가 아닌 의해 I ² , 1>>n%i수득 1 및 (n/i%i<1)수율 0 그 결과,
    1 · 2 ^{7 · 0} = 1 .

  • 경우 N은 로 나누어 I ² , 1>>n%i및 (n/i%i<1)모두 수율 1 결과, 1 · 2 ^{7 · 1} = 128 .

  • 만약 N 로 나눠하지 아니 나 , 1>>n%i수득 0 초래 · 2 0 ^{7 · X} = 0 .

  
  결과 정수의 합이 될 것이다 (2) ^m - 2의 경우 n은 MDP 번호 (해당 인 2 ^분 제수 제외한 1 및 N ) 및 이상의 숫자 크 (127)가 있는 경우 , n은 완벽한 정사각형 요소를 갖는다. 따라서 n 이 7DP 숫자 인 경우에만 합계는 126 입니다.

• 7DP 번호는 합계는 126 이므로 그것을 배타적 논리합, 126 개 수율 0 falsy이다. 따라서 람다의 일부 또는 일부가 실행되고 f 는 현재 값 n을 반환합니다 .

• n 이 7DP 숫자가 아닌 경우 XOR은 0이 아닌 값을 반환합니다. 따라서, 람다 및 일부가 실행된다.

  f(n+k,k%2*2+~k)

  재귀 호출 F를 갱신의 값 N (다음 전위 7DP 번호)와 K (새로운 후보 그 후 하나의 차이).

  경우 K는 짝수, 음이 아닌 정수이고, k%2*2수득 0 및 ~k수율 (K + 1) - . 두 결과의 합은 -(k + 1) 이며 k 보다 절대 값 이 1 보다 큰 홀수 음의 정수입니다. .

  경우 K는 홀수, 양의 정수이며, k%2*2수득 2 개 및 ~k수율 (K + 1) - . 두 결과의 합은 2-(k + 1) =-(k-1) 이며 k 보다 절대 값 이 1 단위 큰 음이 아닌 음의 정수입니다 .

  이는 k 가 0, -1, 2, -3, 4, ⋯ 값을 갖음을 의미 합니다.

  n ₀ (초기 값 n ) 에 누적 적으로 더 해지면 결과 정수는

  • n ₀ + 0
  • ( n은 ₀ + 0) - 1, N = ₀ - 1
  • ( n _0-1 ) + 2 = n ₀ + 1
  • ( n은 ₀ + 1) - (3) = N ₀ - 2
  • ( n은 ₀ - 2) = N + 4 ₀ + 2
  • 기타

  
  만들기는 확실히 우리가 만나는 첫 번째 7DP 번호는 가까이에있다 n은 ₀ 가능한.

Brachylog , 44 40 16 바이트

_{44가 여전히 똑같습니다. 44; (}

:I=+.>0,.$pPdPl7

예:

?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .

이 언어가 항상 빨라지는 것은 아닐까요? 나는 젤리와 MATL을 이겼다!

테스트 케이스 5가 가장 길고 내 컴퓨터에서 약 10 초가 걸립니다.

$p버그가 없으면 12 바이트입니다 (우리는 >0,.부분이 필요하지 않습니다 )

설명

Brachylog는 기본적으로 모든 정수 산술에 제약 조건 논리 프로그래밍을 사용합니다. 또한 내장 레이블 =은 무한한 도메인 에서도 작동합니다.

다음과 같이 제약 조건이없는 (예 : in (-inf, inf)) 변수를 연속적으로 통합합니다 0, 1, -1, 2, -2, 3, ….

따라서 (자동 역 추적 사용) I에서 통합 된 첫 번째 숫자 (7DP 숫자)를 찾아 가장 가까운 7DP 숫자를 얻을 수 있습니다.(-inf, inf)Input + I

:I=                Label variables in [Input, I]. I has no constraints and Input is known
   +.              Unify Output with Input + I
     >0,           Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
        .$pP       Unify P with the list of prime factors of Output
            dP     Check that P with duplicates removed is still P
              l7   Check that the length of P is 7

젤리, 17 바이트

Pµạ³,
×⁹ÆRœc7Ç€ṂṪ

이론적으로 작동하지만 완료하는 데 몇 년이 걸립니다.

주어진 입력에 실제로 작동하는 버전이 있지만 이론적으로 큰 입력에 대해서는 실패합니다.

Pµạ³,
50ÆRœc7Ç€ṂṪ

여기에서 시도하십시오. 이렇게하면 모든 소수가 최대 50 개까지 생성 된 다음 해당 목록에서 소수의 7 개 조합을 찾은 다음 모든 제품을 찾습니다. 마지막으로, 목록에서 주어진 인수에 가장 가까운 요소를 찾습니다.

물론 7DP에 50보다 높은 소수가 들어 있으면 실패합니다. 이론적 버전 은 입력 n에 대해 최대 256n 까지 모든 소수를 생성 하지만 그렇지 않으면 같은 방식으로 작동합니다.

증명

하자 p(x)후 다음 소수를 나타낸다 x. x에 가장 가까운 7DP 제품에 대한 (매우 느슨한) 상한은 다음과 같습니다.

p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))

따라서 [2… p (p (p (p (p (p (p) x)))))] 에서 소수만 확인하면됩니다 . Bertrand의 가정에 따르면 p (x) ≤ 2x 이므로 모든 소수를 최대 128x 까지 검사하면 충분합니다 .

MATL , 21 17 16 14 13 바이트

4 바이트를 제거하고 1 바이트를 더 절약 한 제안에 대해 Dennis에게 감사드립니다!

t17*Zq7XN!pYk

이것은 이론적으로 작동하지만 위의 입력 6(온라인 컴파일러)에 대한 메모리가 부족합니다 .

보다 효율적인 버전은 21 바이트를 사용 하고 약 1 초 안에 모든 테스트 사례를 계산합니다.

t3e4/k16+_YqZq7XN!pYk

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

• 메모리 비효율적 인 버전
• 메모리 효율적인 버전
• 메모리 효율적인 버전, 모든 테스트 사례

설명

메모리 효율적인 버전

입력 N = 860782을 예로 들어 보겠습니다. 또한 최대의 소수를 고려하면 충분 M = 29인 곱한 첫번째 소수 2*3*5*7*11*13N 초과 . 이 예에서는 2*3*5*7*11*13*29 = 870870. 다음은 31입니다. 그 소수 이상을 포함하는 모든 제품은 적어도 2*3*5*7*11*13*31 = 930930이므로 N 이 초과 하는 제품을 초과 하므로 솔루션이 되지 않을 것이 보장 됩니다.870870

M 은보다 큰 첫 번째 소수로 계산됩니다 max(N/(2*3*5*7*11*13), 16). 이 max기능은 최소한 17선택 하도록 보장하는 데 사용됩니다 . 몇 바이트를 절약하기 위해 코드는 2*3*5*7*11*13 = 30030로 대체 되고 추가로 30000기능 max합니다. 이러한 변경은 더 큰 가치를주기 때문에 유효합니다.

t      % Take input implicitly. Duplicate
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime
Zq     % Prime numbers up to that value
7XN    % Combinations of those primes taken 7 at a time. Gives a 2D array
       % with each combination on a different row
!p     % Product of each row
Yk     % Output product that is closest to the input. Implicitly display

메모리 비효율적 인 버전

바이트 수를 더 줄이려면 나누기를 제거 할 수 있습니다. 사실, 17(감사합니다, @Dennis) 를 곱하면 충분합니다 . 이것은 다음 프라임이 포함되도록하고 ( Bertrand의 가정에 의해 ) 결과가 최소한임을 보장합니다 17. 이것은 이론적으로 작동하지만 약보다 큰 입력에 대한 메모리가 부족합니다 6.

코드에서 섹션

3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime

에 의해 대체

17*    % Multiply by 17

파이크, 32 바이트

#PDl 7q.ID}lRlqi*(#)DF-X,)R],She

여기 사용해보십시오!

온라인에서는 작동하지 않습니다. 시간이 초과되었습니다. 이 버전 은 2 개의 서로 다른 소수만 확인하며 더 빠르게 작동합니다. 대상에서 같은 거리에 2 개의 숫자가 있으면 아래쪽 숫자를 선택합니다.

이것은 입력보다 더 크고 7DP 인 숫자를 찾을 때까지 모든 숫자를 거칩니다. 각 숫자에 대해 7DP가 아닌 경우 제거됩니다. 그런 다음 입력보다 큰 7DP 목록이 더 큰 입력을 갖습니다. 그런 다음 입력에 가장 가까운 것을 선택합니다.

줄리아, 59 바이트

!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n

이것은 매우 비효율적이지만 실제로는 첫 번째 테스트 사례와 이론적으로 다른 테스트 사례에 효과적입니다.

총 64 바이트에 대해 5 바이트 추가 비용으로 효율성을 크게 향상시킬 수 있습니다.

!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n

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

배경

@LuisMendo의 답변 에서 언급했듯이 가장 가까운 7DP 숫자에 대해 고려해야 할 소수는 매우 작습니다. 세트는 입력 n 보다 큰 7DP 숫자를 포함하기에 충분하며, 30300p = 2 · 3 · 5 · 7 · 11 · 13 · p 와 같이 소수 p ≥ 17을 포함하는 경우에만 해당됩니다. ≥n .

에서는 적어도 하나 개의 소수를 포함하는 구간에서 구간 증명 [X, 1.5)가 적어도 하나 개의 소수를 포함 할 때마다 , X ≥ 8 . 이후 30030 / 16384 ≈ 1.83 , 그 수단은 프라임이 있어야 P 의 (N / 30030, N / 16384) 마다 N> 8 * 30300 = 242400 .

마지막으로 n <510510 인 경우 p = 17 이면 충분하므로 최대 n / 16384 + 17 까지의 소수만 고려하면됩니다 .

효율성을 대가로 대신 최대 17n의 소수를 고려할 수 있습니다 . 이 일 N = 1 및보다 대폭 크다 N / 16384 + 17 의 더 큰 값에 해당 .

작동 원리

17n|>primes및 n>>14+17|>primes(bitshift 의해 분할 동등 2 ¹⁴ = 16384 이전 단락에서 언급 된 주요 범위를 계산). 그런 다음 combinations(...,7)해당 범위에있는 7 개의 다른 소수로 구성된 모든 배열을 prod계산하고 이들에 매핑 하면 제품, 즉 답을 선택할 7DP 숫자가 계산됩니다.

다음으로, 7DP 번호마다 n prom을 -n빼고 , 그 차이를 절대 값으로 정렬합니다. 마지막으로와의 첫 번째 차이를 선택하고와 함께 n 을 추가하여 해당 7DP 수를 계산합니다 .sort(...,by=abs)[]+n

Pyth, 30 바이트

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

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

테스트 스위트.

(5를 실행하는 데 시간이 너무 오래 걸림)

설명

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

L&{IPbq7lPb     Defines a function y, whose argument is b:
 &                  Return if both the following are true:
  {IPb                  the prime factorization contains no duplicate; and:
      q7lPb             the number of prime factors is 7

           y#.W!syMH,hhZa0teZ,   The main programme. Input as Q.
                             ,QQ Implicit arguments, yield [Q,Q].
             .W                  While
               !syMH                   both numbers do not satisfy y:
                    ,hhZ             increment the first number
                          teZ        and decrement the second number
                        a0           while making it non-negative.

Mathematica 136 80 75 바이트

이는 외부에서 작업하는 간단한 접근 방식입니다 n.

n는 소수 요인이 7 ( PrimeNu@#==7)이고 이러한 요인 중 어느 것도 두 번 이상 나타나지 않는 경우 (7) 뚜렷한 7 가지 주요 제품 SquareFreeQ@#&입니다.

g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)

이전의 제출물 (136 바이트)은 위의 첫 번째 7 개 고유 프라임 제품 n과 존재하는 경우 아래의 첫 번째 7 개 고유 프라임 제품을 모두 찾았습니다 n. 그런 다음 간단히 어느쪽에 더 가까운지를 결정했습니다 n. 제품이 등거리 인 경우 둘 다 반환했습니다.

현재 버전은 n-1, n + 1, n-2, n + 2 ...가 첫 번째 7 개의 주요 프라임 제품에 도달 할 때까지 확인합니다. 이보다 효율적인 버전은 Dennis가 취한 접근 방식을 채택합니다.

주요 발전은 ⌊k/2](-1)^k⌋0, 1, -1, 2, -2 시리즈를 반환하는 데 사용되었습니다. 0은 n7 고유 프라이밍 제품 인지 여부를 확인하는 데 사용됩니다 . 이러한 이유로 Floor(즉, ⌊...⌋)가 대신 사용됩니다 Ceiling.

g[5]
g[860782]
g[1425060]

510510

870870

1438710

05AB1E , 10 바이트

°Åp7.ÆPs.x

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

처음 10 ** 입력 프라임 중 7 개의 모든 조합을 시도합니다. 1보다 큰 입력에 대한 메모리가 부족합니다.

훨씬 더 효율적인 14 바이트 버전 :

5°/7+Åp7.ÆPs.x

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

첫 번째 (입력 / 100000 + 7) 소수를 사용합니다.