_{(qua trò chuyện )}

Mục nhập OEIS A123321 liệt kê chuỗi các số là sản phẩm của bảy số nguyên tố riêng biệt. Để cho ngắn gọn, chúng tôi sẽ gọi đây là số 7DP . Một vài số đầu tiên và ước số tương ứng của chúng ở bên dưới:

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

Thách thức ở đây sẽ là tìm ra số 7DP gần nhất, về khoảng cách tuyệt đối, từ một đầu vào nhất định.

Đầu vào

Một số nguyên dương n duy nhất trong bất kỳ định dạng thuận tiện .

Đầu ra

Số 7DP gần nhất với n , một lần nữa ở bất kỳ định dạng thuận tiện. Nếu hai số 7DP được gắn gần nhất, bạn có thể xuất một hoặc cả hai.

Quy tắc

• Các số có thể được coi là phù hợp với [int]kiểu dữ liệu mặc định của ngôn ngữ của bạn (hoặc tương đương).
• Hoặc là một chương trình đầy đủ hoặc một chức năng được chấp nhận.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn , vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất sẽ thắng.

Ví dụ

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

Python, 89 86 85 byte

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

Thuật toán là O (đáng sợ) để bắt đầu và đệ quy không thực sự có ích, nhưng nó hoạt động tốt miễn là n đủ gần với số 7DP.

Cảm ơn @xnor vì đã chơi golf 3 byte!

Thử nghiệm nó trên repl.it .

Làm thế nào nó hoạt động

Python không có các phần tử nguyên thủy hoặc tích hợp, nhưng chúng ta có thể xác định các số 7DP theo số lượng và tính chất của các ước số của chúng.

Theo nguyên tắc nhân, số lượng ước của một số nguyên có thể được tính là tích của số mũ tăng dần của hệ số nguyên tố của nó. Do đó, σ ₀ (n) ( hàm chia ) là 2 ^m mỗi khi n là số mDP.

σ ₀ (n) = 128 là một điều kiện cần thiết, nhưng nó không đủ; ví dụ: σ ₀ (2 ¹²⁷ ) = 128 , nhưng 2 ¹²⁷ rõ ràng không phải là số 7DP. Tuy nhiên, nếu cả hai σ ₀ (n) = 128 và không hoàn hảo chia vuông n đồng đều, sau đó n là một số 7DP.

Đối với đầu vào n , thuật toán bao gồm kiểm tra các số nguyên n , n - 1 , n + 1 , n - 2 , n + 2 , v.v. và trả về số đầu tiên là số 7DP.

Khi f được gọi với đối số n , điều sau đây xảy ra:

• Mật mã

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

  kiểm tra nếu n là không một số 7DP như sau.

  Đối với tất cả các số nguyên i sao cho 1 <i <n , 1>>n%i<<7*(n/i%i<1)được ước tính.

  • Nếu n chia hết cho i nhưng không bằng i ² , 1>>n%imang lại 1 và (n/i%i<1)mang lại 0 , dẫn đến
    1 · 2 ^{7 · 0} = 1 .

  • Nếu n chia hết cho i ² , 1>>n%ivà (n/i%i<1)cả sản lượng 1 , kết quả là 1 · 2 ^{7 · 1} = 128 .

  • Nếu n không chia hết cho i , 1>>n%isinh ra 0 , kết quả là 0 · 2 ^{7 · x} = 0 .

  
  Tổng các số nguyên kết quả sẽ là 2 ^m - 2 nếu n là một số MDP (nó 2 ^m ước, trừ 1 và n ) và lớn hơn số hơn 127 nếu n có một yếu tố vuông hoàn hảo. Do đó, tổng sẽ là 126 khi và chỉ khi n là số 7DP.

• Đối với các số 7DP, tổng là 126 , do đó, XOR nó với 126 mang lại 0 , là sai. Do đó, hoặc một phần của lambda được thực thi và f trả về giá trị hiện tại của n .

• Nếu n không phải là số 7DP, XOR sẽ trả về giá trị trung thực, khác không. Do đó, và một phần của lambda được thực thi.

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

  gọi đệ quy f với các giá trị được cập nhật là n (số 7DP tiềm năng tiếp theo) và k (sự khác biệt giữa ứng cử viên mới và ứng viên sau đó).

  Nếu k là số nguyên chẵn, không âm, k%2*2mang lại 0 và ~kmang lại - (k + 1) . Tổng của cả hai kết quả là - (k + 1) , đó là một số lẻ, số nguyên âm đó là 1 lớn hơn về giá trị tuyệt đối hơn k .

  Nếu k là số nguyên lẻ, âm, k%2*2mang lại 2 và ~kmang lại - (k + 1) . Tổng của cả hai kết quả là 2 - (k + 1) = - (k - 1) , là số nguyên chẵn, không âm có giá trị tuyệt đối lớn hơn 1 đơn vị so với k .

  Điều này có nghĩa là k lấy các giá trị 0, -1, 2, -3, 4 ,.

  Khi được cộng dồn vào n ₀ (giá trị ban đầu của n ), các số nguyên kết quả là

  • n ₀ + 0
  • ( n ₀ + 0) - 1 = n ₀ - 1
  • ( n ₀ - 1) + 2 = n ₀ + 1
  • ( n ₀ + 1) - 3 = n ₀ - 2
  • ( n ₀ - 2) + 4 = n ₀ + 2
  • Vân vân.

  
  đảm bảo số lượng 7DP đầu tiên chúng tôi gặp phải là càng gần với n ₀ càng tốt.

Brachylog , 44 40 16 byte

_{Vượt qua 44 vẫn là 44 thường xuyên (}

:I=+.>0,.$pPdPl7

Thí dụ:

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

Có thể là ngôn ngữ này không phải lúc nào cũng hút? Tôi đã đánh bại Jelly và MATL!

Trường hợp thử nghiệm 5dài nhất và mất khoảng 10 giây trên máy của tôi.

Đây sẽ là 12 byte nếu $pkhông bị lỗi (chúng tôi sẽ không cần >0,.phần đó)

Giải trình

Brachylog sử dụng lập trình logic ràng buộc theo mặc định cho tất cả số học số nguyên. Hơn nữa, việc ghi nhãn tích hợp =hoạt động trên các miền có thể vô hạn.

Nó liên tiếp thống nhất một biến không có ràng buộc (tức là (-inf, inf)) như vậy : 0, 1, -1, 2, -2, 3, ….

Do đó, chúng tôi có thể nhận được số 7DP gần nhất bằng cách tìm số đầu tiên được Ithống nhất (-inf, inf)(sử dụng quay lui tự động), với Input + Isố 7DP.

: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

Thạch, 17 byte

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

Hoạt động trên lý thuyết, nhưng phải mất nhiều năm để hoàn thành.

Đây là một phiên bản thực sự hoạt động cho các đầu vào nhất định, nhưng về mặt lý thuyết thất bại cho các đầu vào lớn:

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

Hãy thử nó ở đây. Điều này tạo ra tất cả các số nguyên tố lên tới 50, sau đó tìm thấy tất cả 7 tổ hợp số nguyên tố trong danh sách đó, và sau đó là tất cả các sản phẩm của chúng. Cuối cùng, nó chỉ đơn giản là tìm phần tử gần nhất từ ​​danh sách đó đến đối số đã cho.

Tất nhiên, một khi 7DP của chúng tôi chứa các số nguyên tố cao hơn 50, điều này sẽ thất bại. Phiên bản lý thuyết tạo ra tất cả các số nguyên tố lên tới 256n cho một đầu vào n , nhưng mặt khác hoạt động theo cùng một cách.

Bằng chứng

Hãy p(x)biểu thị số nguyên tố tiếp theo sau x. Một giới hạn trên (cực kỳ lỏng lẻo) cho sản phẩm 7DP gần nhất với x là:

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

Vì vậy, chúng ta chỉ cần kiểm tra các số nguyên tố trong [2io p (p (p (p (p (p (x)))))))] . Định đề của Bertrand nói rằng p (x) ≤ 2x , do đó, đủ để kiểm tra tất cả các số nguyên tố lên tới 128x .

MATL , 21 17 16 14 13 byte

Cảm ơn Dennis vì một đề nghị đã loại bỏ 4 byte và một byte khác đã lưu thêm 1 byte!

t17*Zq7XN!pYk

Điều này hoạt động trên lý thuyết, nhưng hết bộ nhớ cho các đầu vào ở trên 6(trình biên dịch trực tuyến).

Một phiên bản hiệu quả hơn sử dụng 21 byte và tính toán tất cả các trường hợp thử nghiệm trong khoảng một giây:

t3e4/k16+_YqZq7XN!pYk

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

• Phiên bản không hiệu quả bộ nhớ
• Phiên bản hiệu quả bộ nhớ
• Phiên bản hiệu quả bộ nhớ, tất cả các trường hợp thử nghiệm

Giải trình

Phiên bản hiệu quả bộ nhớ

Lấy đầu vào N = 860782làm ví dụ. Nó cũng đủ để xem xét số nguyên tố lên đến M = 29, đó là nguyên tố đầu tiên mà nhân 2*3*5*7*11*13vượt N . Trong ví dụ này , 2*3*5*7*11*13*29 = 870870. Nguyên tố tiếp theo là 31. Bất kỳ sản phẩm liên quan về việc thủ hoặc cao hơn sẽ có ít nhất 2*3*5*7*11*13*31 = 930930, và vì vậy nó được bảo đảm không phải là giải pháp, vì nó vượt quá 870870vượt quá N .

M được tính là số nguyên tố đầu tiên lớn hơn max(N/(2*3*5*7*11*13), 16). Các maxchức năng được sử dụng để đảm bảo rằng ít nhất 17được chọn. Để lưu một vài byte, mã thay thế 2*3*5*7*11*13 = 30030bằng 30000và thêm chức năng max. Những thay đổi này là hợp lệ vì chúng cho giá trị lớn hơn.

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

Phiên bản không hiệu quả bộ nhớ

Để tiếp tục giảm số lượng byte, phân chia có thể được loại bỏ; thực tế, nó đủ để nhân lên 17(cảm ơn, @Dennis). Điều này đảm bảo rằng nguyên tố tiếp theo được bao gồm (theo định đề của Bertrand ) và ít nhất là kết quả 17. Điều này hoạt động trên lý thuyết, nhưng hết bộ nhớ cho các đầu vào lớn hơn khoảng 6.

Trong mã, phần

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

được thay thế bởi

17*    % Multiply by 17

Pyke, 32 byte

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

Hãy thử nó ở đây!

Lưu ý điều này không hoạt động trực tuyến - nó hết thời gian. Phiên bản này chỉ kiểm tra 2 số nguyên tố riêng biệt và sẽ hoạt động nhanh hơn. Khi có 2 số có cùng khoảng cách với mục tiêu, nó sẽ chọn số thấp hơn.

Điều này đi qua tất cả các số cho đến khi nó tìm thấy một số lớn hơn đầu vào và là 7DP. Đối với mỗi số, nó sẽ bị loại bỏ nếu không phải là 7DP. Sau đó, nó có một danh sách 7DP cho đến đầu vào với một cái lớn hơn. Sau đó, nó chọn một cái gần nhất với đầu vào.

Julia, 59 byte

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

Điều này rất không hiệu quả, nhưng nó hoạt động cho trường hợp thử nghiệm đầu tiên trong thực tế và cho những người khác về lý thuyết.

Với chi phí thêm 5 byte - với tổng số 64 byte - hiệu quả có thể được cải thiện đáng kể.

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

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

Lý lịch

Như đã đề cập trong câu trả lời của @ LuisMendo , tập hợp các số nguyên tố chúng ta phải xem xét cho số 7DP gần nhất là khá nhỏ. Nó đủ cho tập hợp chứa số 7DP lớn hơn số n đầu vào , điều này sẽ đúng khi và chỉ khi nó chứa số nguyên tố p such 17 sao cho 30300p = 2 · 3 · 5 · 7 · 11 · 13 · p ≥ n .

Trong Trên khoảng chứa ít nhất một số nguyên tố chứng tỏ rằng khoảng [x, 1,5x) chứa ít nhất một số nguyên tố bất cứ khi nào x 8 . Kể từ 30030/16384 ≈ 1,83 , điều đó có nghĩa là phải có một số nguyên tố p trong (n / 30030, n / 16384) bất cứ khi nào n> 8 · 30300 = 242400 .

Cuối cùng, khi n <510510 , p = 17 rõ ràng là đủ, vì vậy chúng ta chỉ cần xem xét các số nguyên tố lên đến n / 16384 + 17 .

Thay vào đó , chúng ta có thể xem xét các số nguyên tố lên tới 17n . Điều này hoạt động khi n = 1 và lớn hơn n / 16384 + 17 cho các giá trị lớn hơn của n .

Làm thế nào nó hoạt động

17n|>primesvà n>>14+17|>primes(bithift tương đương với việc chia cho 2 ¹⁴ = 16384 ) tính các phạm vi nguyên tố được đề cập trong đoạn trước. Sau đó, combinations(...,7)tính toán tất cả các mảng gồm bảy số nguyên tố khác nhau trong phạm vi đó và ánh xạ prodqua các số đó tính toán các sản phẩm của chúng, tức là các số 7DP mà chúng tôi sẽ chọn câu trả lời.

Tiếp theo, -ntrừ n prom mỗi số 7DP, sau đó sort(...,by=abs)sắp xếp các khác biệt đó theo các giá trị tuyệt đối của chúng. Cuối cùng, chúng tôi chọn sự khác biệt đầu tiên với []và tính số 7DP tương ứng bằng cách thêm n với +n.

Bình thường, 30 byte

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

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

Bộ thử nghiệm.

(5 mất quá nhiều thời gian để chạy)

Giải trình

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.

Toán học 136 80 75 byte

Đây là một cách tiếp cận đơn giản, làm việc từ bên ngoài n.

nlà một sản phẩm 7 số riêng biệt nếu số lượng các yếu tố chính là 7 ( PrimeNu@#==7) và không có yếu tố nào trong số này xuất hiện nhiều hơn một lần ( SquareFreeQ@#&).

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

Trình trước đó của tôi (136 byte) đã tìm thấy cả sản phẩm 7 số riêng biệt đầu tiên ở trên nvà, nếu nó tồn tại, sản phẩm 7 số riêng biệt đầu tiên bên dưới n. Sau đó, nó chỉ đơn giản là xác định cái nào gần hơn n. Nếu các sản phẩm là tương đương, nó trả lại cả hai.

Phiên bản hiện tại kiểm tra n-1, n + 1, n-2, n + 2 ... cho đến khi đạt đến sản phẩm 7 số riêng biệt đầu tiên. Phiên bản hiệu quả hơn này thông qua cách tiếp cận mà Dennis đã thực hiện.

Bước tiến quan trọng là sử dụng ⌊k/2](-1)^k⌋để trả về nsê-ri , 0, 1, -1, 2, -2 ... Số 0 được sử dụng để kiểm tra xem bản thân nó có phải là sản phẩm 7 số riêng biệt hay không. Vì lý do này, Floor(đó là, ⌊...⌋) được sử dụng thay vì Ceiling.

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

510510

870870

1438710

05AB1E , 10 byte

°Åp7.ÆPs.x

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

Thử tất cả các kết hợp của 7 trong số 10 số nguyên tố đầu vào ** đầu tiên. Hết bộ nhớ cho các đầu vào lớn hơn 1.

Phiên bản 14 byte hiệu quả hơn đáng kể:

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

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

Sử dụng các số nguyên tố đầu tiên (đầu vào / 100000 + 7).