(Theo dõi câu hỏi của tôi về việc hoán đổi bit với hàng xóm của họ .)

Bài tập

Cho một số nguyên dương x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) · khắc , in số nguyên thu được bằng cách hoán đổi số mũ trong hệ số này cho mỗi cặp số nguyên tố liên tiếp y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) · Cách

A061898 trong OEIS. Đây là môn đánh gôn , vì vậy chương trình ngắn nhất (tính bằng byte) sẽ thắng!

Các trường hợp thử nghiệm

1 -> 1
2 -> 3
3 -> 2
10 -> 21
37 -> 31
360 -> 756
12345 -> 11578
67895678 -> 125630871

Thạch , 10 byte

ÆE;0s2UFÆẸ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

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

ÆE;0s2UFÆẸ  Main link. Argument: n

ÆE          Yield the exponents of n's prime factorization.
  ;0        Append a zero.
    s2      Split into pairs.
      U     Upend; reverse each pair.
       F    Flatten the resulting list of pairs.
        ÆẸ  Convert the prime exponents to integer.

Thạch, 17 16 11 byte

5 byte nhờ Dennis.

ÆfÆC’^1‘ÆNP

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

Giải trình

ÆfÆC’^1‘ÆNP   Main monadic chain. Argument: n

Æf            Yield the prime factors of n.
  ÆC          For each factor, count the number of primes below it.
              This effectively yields their indices.
    ’         Decrement [each] by 1.
     ^1       Xor with 1
       ‘      Increment [each] by 1.
        ÆN    Find their corresponding primes.
          P   Yield their product.

Phiên bản 16 byte trước đó

ÆnÆRiЀÆf’^1‘ÆNP

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

Giải trình

ÆnÆRiЀÆf’^1‘ÆNP   Main monadic chain. Argument: n

Æn                 Yield the next prime from n.
  ÆR               Yield all primes from 2 to it.
       Æf          Yield prime factors of n
    iЀ            Yield their index in the prime list.
         ’         Decrement [each] by 1.
          ^1       Xor with 1
            ‘      Increment [each] by 1.
             ÆN    Find their corresponding primes.
               P   Yield their product.

Phiên bản 17 byte trước:

ÆnÆR©iЀÆf’^1‘ị®P

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

Giải trình

ÆnÆR©iЀÆf’^1‘ị®P   Main monadic chain. Argument: n

Æn                  Yield the next prime from n.
  ÆR                Yield all primes from 2 to it.
    ©               Store to register.
        Æf          Yield prime factors of n
     iЀ            Yield their index in the prime list.
          ’         Decrement [each] by 1.
           ^1       Xor with 1
             ‘      Increment [each] by 1.
              ị®    Find their corresponding primes in
                    the list in register.
                P   Yield their product.

Toán học, 70 69 byte

1##&@@(Prime[BitXor[PrimePi@#+1,1]-1]^#2&)@@@FactorInteger@#/._@_->1&

Một hàm không tên lấy và trả về một số nguyên. Nó ném một lỗi vào đầu vào1 nhưng vẫn tính kết quả chính xác.

Giải trình

Như thường lệ, do tất cả các cú pháp cú pháp, thứ tự đọc là một chút buồn cười. Một &trên định nghĩa đúng một chức năng vô danh và đối số của nó được gọi bằng #, #2, #3vv

...FactorInteger@#...

Chúng tôi bắt đầu bằng cách bao thanh toán đầu vào. Điều này đưa ra một danh sách các cặp {prime, exponent}ví dụ đầu vào 12cho {{2, 2}, {3, 1}}. Hơi bất tiện, 1cho {{1, 1}}.

(...&)@@@...

Điều này áp dụng hàm bên trái cho danh sách các số nguyên ở cấp 1, đó là hàm được gọi cho mỗi cặp, chuyển số nguyên tố và số mũ thành các đối số riêng biệt, sau đó trả về danh sách kết quả. (Điều này tương tự như ánh xạ hàm qua danh sách, nhưng nhận hai đối số riêng biệt sẽ thuận tiện hơn so với nhận một cặp.)

...PrimePi@#...

Chúng tôi tính toán số lượng các số nguyên tố lên đến và bao gồm đầu vào (số nguyên tố) bằng cách sử dụng tích hợp PrimePi. Điều này cho chúng ta chỉ số của nguyên tố.

...BitXor[...+1,1]-1...

Kết quả được tăng lên, XOR'ed với 1và giảm xuống một lần nữa. Hoán đổi này 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., tức là tất cả các chỉ số dựa trên 1. Lưu ý rằng đầu vào 1sẽ mang lại 0cho PrimePisau đó được ánh xạ tới -1trong quá trình này. Chúng ta sẽ giải quyết nó sau.

 ...Prime[...]^#2...

Bây giờ chúng ta có được số nguyên tố thứ n (trong đó n là kết quả của phép tính trước đó), là số nguyên tố được hoán đổi chính xác và nâng nó lên lũy thừa của số nguyên tố ban đầu trong hệ số của đầu vào. Tại thời điểm Prime[-1]này sẽ ném một lỗi nhưng sẽ trở lại không đánh giá được. Sức mạnh trong trường hợp này là 1do toàn bộ quá trình cho đến nay mang lại {Prime[-1]}đầu vào 1và một danh sách các quyền hạn chính xác cho tất cả các đầu vào khác.

 1##&@@...

Tiếp theo, chúng tôi chỉ cần nhân lên tất cả các quyền hạn. 1##&là một thủ thuật đánh golf tiêu chuẩn cho Timeschức năng. Xem mẹo này (phần "Trình tự lập luận") để biết cách hoạt động của nó.

Cuối cùng, chúng ta cần quan tâm đến đầu vào 1mà tất cả các kết quả trên dẫn đến Prime[-1]. Chúng ta có thể dễ dàng khắc phục điều đó bằng một quy tắc thay thế đơn giản. Hãy nhớ rằng đó f@xlà viết tắt của f[x]. Chúng tôi chỉ muốn khớp bất kỳ biểu thức nào của dạng đó (vì tất cả các kết quả khác sẽ là số nguyên, tức là biểu thức nguyên tử) và thay thế nó bằng 1:

.../._@_->1

Ở đây, /.viết tắt của ReplaceAll, _@_là một mẫu cho bất kỳ dạng nào f[x](nghĩa là bất kỳ biểu thức ghép nào với một con) và ->1nói "thay thế bằng 1".

Con trăn 2, 149 139 byte

10 byte nhờ Dennis.

n=input()
p=f=1;w=[2]
while w[-1]<=n:f*=p;p+=1;w+=[p]*(-~f%p<1)
r=p=1;w=w[1:]
while n>1:
    p+=1
    while n%p<1:n/=p;r*=w[w.index(p)^1]
print r

MATL , 17 byte

EZqGYfy&mt2\Eq+)p

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

Giải trình

Điều này không sử dụng số mũ trực tiếp. Thay vào đó, nó hoán đổi từng yếu tố (có thể lặp lại) bởi nguyên tố tiếp theo hoặc nguyên tố trước.

EZq    % Implicit input. Multiply by 2
Zq     % Array with sequence of primes up to that (this is more than enough)
GYf    % Prime factors of input, with possible repetitions
y      % Duplicate array with sequence of primes
&m     % Indices of prime factors in the sequence of primes
t2\    % Duplicate, modulo 2. Gives 0 for even indices, 1 for odd
Eq     % Multiply by 2, add 1. Transforms 0 / 1 into -1 / 1 
+      % Add. This modifies the indices to perform the swapping
)      % Apply the new indices into the sequence of primes
p      % Product. Implicit display

Julia, 64 byte

~=primes
!n=prod(t->(~3n)[endof(~t[1])+1$1-1]^t[2],factor(2n))/3

Hãy thử trực tuyến! Trường hợp thử nghiệm cuối cùng yêu cầu quá nhiều bộ nhớ cho TIO, nhưng tôi đã xác minh nó cục bộ.

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

Để tránh đầu vào vỏ đặc biệt 1 - sản phẩm của một từ điển trống không được xác định - chúng tôi nhân n đầu vào với 2 và chia kết quả cuối cùng cho cặp 3 của nó .

factor(2n)đưa ra tất cả các số mũ dương của các thừa số nguyên tố 2n như một từ điển. Khi lặp lại từ điển, chúng ta sẽ nhận được các cặp khóa-giá trị / số mũ. Hàm prodsẽ lấy các cặp này, áp dụng hàm ẩn danh t->...cho chúng và trả về sản phẩm của kết quả.

Đối với mỗi cặp t = (p, e) , endof(~t[1])hoặc endof(primes(t[1]))trở lại k , số lượng các số nguyên tố mà ít hoặc bằng p , nghĩa là p là k ^th thủ.

+1$1-1sẽ tăng k , XOR k + 1 với 1 và giảm kết quả. Nếu k là số lẻ, k + 1 là số chẵn, do đó XOR tăng và kết quả cuối cùng là k + 1 . Nếu k chẵn, k + 1 là số lẻ, do đó XOR giảm và kết quả cuối cùng là k - 1 .

Cuối cùng, chúng tôi tính tất cả các số nguyên tố nhỏ hơn hoặc bằng 3n với (~3n)hoặc primes(3n)(hệ số nguyên tố cao nhất của 2n nhỏ hơn hoặc bằng n nếu n> 2 và luôn có một số nguyên tố giữa n và 2n ), chọn một số nguyên tố trong chỉ số k + 1 hoặc k - 1 , và nâng nó lên sức mạnh ^thứ e với .^t[2]

Python 2, 112 109 108 95 94 byte

f=lambda n,k=4,m=6,p=[3,2]:1/n or n%p[1]and f(n,k+1,m*k,m*m%k*[k]+p)or p[len(p)*2%4]*f(n/p[1])

Kiểm tra nó trên Ideone .

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

Khi f được gọi, đầu tiên nó sẽ tính 1 / n . Nếu kết quả khác không, n là 1 và f trả về 1 .

Nếu n> 1 , điều sau đây xảy ra.

• Nếu n không chia hết cho p [1] (ban đầu 2 ), n%p[1]mang lại giá trị trung thực và

  f(n,k+1,m*k,m*m%k*[k]+p)

  được gọi.

  Nhánh này tạo ra số nguyên tố cho đến khi áp chót chia đều n . Để làm như vậy, nó sử dụng hệ quả của định lý Wilson sau đây .

  

  Tại mọi thời điểm, m đều bằng giai thừa của k - 1 (ban đầu là 6 = 3! Và 4. Trong mỗi lần lặp, kết quả của việc m*m%k*[k]được đưa vào danh sách các số nguyên tố p . Theo hệ quả, m*m%klà 1 nếu k là số nguyên tố và 0 nếu không, vì vậy điều này trả trước k cho p khi và chỉ khi k là số nguyên tố.

• Nếu n chia hết cho p [1] , n%p[1]mang lại 0 và

  p[len(p)*2%4]*f(n/p[1])

  được thực thi.

  Nếu p chứa một số nguyên tố chẵn, len(p)*2%4sẽ sinh ra 0 và bội số đầu tiên lấy giá trị của p [0] . Nếu p chứa một số lẻ các số nguyên tố, len(p)*2%4sẽ sinh ra 2 và bội số đầu tiên lấy giá trị của p [2] .

  Trong cả hai trường hợp, đây là số nguyên tố mà số mũ của nó phải được hoán đổi với một trong số p [1] , vì vậy chúng ta chia n cho p [1] (giảm số mũ của 1 ) và nhân kết quả của f(n/p[1])số nguyên tố tương ứng (tăng số mũ của 1 ).

  Lưu ý rằng f(n/p[1])đặt lại k , m và p về giá trị mặc định của chúng. f(n/p[1],k,m,p)sẽ cải thiện hiệu quả, với chi phí thêm sáu byte.

Bình thường, 25 byte

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Bộ thử nghiệm.

Giải trình

JfP_TSfP_ThQ*F+1m@Jx1xJdP

           Q    get input
          h     add one
      fP_T      find the first prime after it
     S          range from 1 to that prime
 fP_T           filter for the primes
J               assign to J

                        P  prime factorize input
                m      d   for each factor
                     xJ    find its index in J
                   x1      xor with 1
                 @J        find the corresponding entry in J
            *F+1           product of the whole list

Julia, 155 131 127 byte

n->(x=[sort([merge([p=>0for p=primes(n+1)],factor(n))...]);1=>0];prod([x[i-1][1]^x[i][2]*x[i][1]^x[i-1][2]for i=2:2:endof(x)]))

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một số nguyên. Để gọi nó, gán nó cho một biến. Nó yêu cầu phiên bản Julia <0,5 vì chức năng chính đã bị xóa khỏi Base trong 0,5.

Ung dung:

function f(n::Int)
    # Create an array of pairs by merging the Dict created from factoring n
    # with all primes less than n+1 with a 0 exponent. Append an extra pair
    # to account for 1 and situations where x would otherwise have odd length.
    x = [sort([(merge([p=>0 for p in primes(n+1)], factor(n))...]); 1=>0]

    # Compute a^d * c^b, where a and c are primes with b and d as their
    # respective exponents.
    prod([x[i-1][1]^x[i][2] * x[i][1]^x[i-1][2] for i = 2:2:endof(x)])
end

Hãy thử trực tuyến! (Bao gồm tất cả các trường hợp thử nghiệm)

Trên thực tế, 15 byte

w`i;r♂Pí1^Pn`Mπ

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

Giải trình:

w`i;r♂Pí1^Pn`Mπ
w                prime factorization
 `          `M   map (for (p,e) in factorization):
  i;               flatten, make a copy of p
    r♂P            [prime[i] for i in range(p)]
       í           index (essentially the 0-based prime index of p)
        1^         XOR with 1
          P        prime[n]
           n       repeat e times
              π  product

05AB1E, 22 byte

Ó¾‚˜2ô€R˜DgL<Ø)øvy`smP

Giải thích

Ó¾‚˜                    # list of primeexponents with a 0 appended: n=10 -> [1,0,1,0] 
    2ô                  # split into pairs: [[1,0],[1,0]]
      €R˜               # reverse each pair and flatten: [0,1,0,1]
         DgL<Ø          # get list of primes corresponding to the exponents: [2,3,5,7]
              )ø        # zip lists: [[0,2],[1,3],[0,5],[1,7]]
                vy`sm   # raise each prime to its new exponent: [1,3,1,7]
                     P  # product: 21

Dùng thử trực tuyến

J, 21 byte

([:,_2|.\,&0)&.(_&q:)

Lấy số mũ nguyên tố của n là với số không. Sau đó phân vùng chúng thành các danh sách con không chồng lấp có kích thước 2 trong khi điền thêm 0. Sau đó đảo ngược từng danh sách con và san phẳng chúng thành một danh sách. Cuối cùng, chuyển đổi trở lại từ số mũ nguyên tố thành một số.

Sử dụng

   f =: ([:,_2|.\,&0)&.(_&q:)
   (,.f"0) 1 2 3 10 37 360 12345
    1     1
    2     3
    3     2
   10    21
   37    31
  360   756
12345 11578
   f 67895678x
125630871

Giải trình

([:,_2|.\,&0)&.(_&q:)  Input: n
                _&q:   Obtain the list of prime exponents
(           )&.        Apply to the list of prime exponenets
         ,&0           Append a zero to the end of the list
    _2  \              Split the list into nonoverlapping sublists of size 2
      |.               Reverse each sublist
 [:,                   Flatten the list of sublists into a list
             &.(    )  Apply the inverse of (Obtain the list of prime exponents)
                       to convert back to a number and return it