（跟进有关与邻居交换位的问题。）

任务

给定一个正整数x =（2 ^a  ·3 ^b）·（5 ^c  ·7 ^d）·（11 ^e  ·13 ^f）·…，打印通过交换因式分解中的每个连续对素数对的指数而获得的整数，y =（2 ^b  ·3 ^a）·（5 ^d  ·7 ^c）·（11 ^f  ·13 ^e）·…

OEIS中的A061898。这是代码高尔夫球，因此最短的程序（以字节为单位）获胜！

测试用例

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

果冻，10 字节

ÆE;0s2UFÆẸ

在线尝试！或验证所有测试用例。

怎么运行的

Æ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.

Jelly，17 16 11个字节

5个字节感谢丹尼斯。

ÆfÆC’^1‘ÆNP

在线尝试！

说明

Æ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.

以前的16字节版本

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

在线尝试！

说明

Æ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.

先前的17字节版本：

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

在线尝试！

说明

Æ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.

Mathematica，70 69字节

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

一个未命名的函数，它接受并返回一个整数。它在输入上引发错误，1但仍会计算正确的结果。

说明

像往常一样，由于所有语法糖，阅读顺序有点有趣。甲&右边定义的未命名函数和它的参数被称为通过#，#2，#3等。

...FactorInteger@#...

我们首先考虑输入因素。这给出了一个对的列表，{prime, exponent}例如input 12Gives {{2, 2}, {3, 1}}。1给您带来一些不便{{1, 1}}。

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

这会将左侧的函数应用于级别1的整数列表，即对于每对调用该函数，将质数和指数作为单独的参数传递，然后返回结果列表。（这类似于在列表上映射函数，但是接收两个单独的参数比接收一对更方便。）

...PrimePi@#...

我们使用内建函数计算直到（包括）输入的素数数量PrimePi。这给了我们素数的指数。

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

结果递增，与异1或后再次递减。交换1 <-> 2, 3 <-> 4, 5 <-> 6, ...，即所有基于1的索引。请注意，输入1将产生收益0，PrimePi然后-1在此过程中将其映射到该收益。我们稍后再处理。

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

现在，我们获得第n个素数（其中n是先前计算的结果），它是正确交换的素数，并在输入的因式分解中将其提高到原始素数的幂。此时Prime[-1]将引发错误，但将返回未经评估的状态。在这种情况下，功率是1这样的：到目前为止，整个过程都产生{Prime[-1]}输入，1并列出所有其他输入的正确主功率。

 1##&@@...

接下来，我们将所有素数乘以。1##&是该Times功能的标准高尔夫技巧。有关其工作原理，请参见本技巧（“参数序列”一节）。

最后，我们需要注意1上述所有导致的输入Prime[-1]。我们可以通过简单的替换规则轻松解决该问题。请记住，这f@x是的缩写f[x]。我们只想匹配该形式的任何表达式（因为所有其他结果都是整数，即原子表达式），然后将其替换为1：

.../._@_->1

在这里，/.是的缩写ReplaceAll，_@_是任何形式的模式f[x]（即带有单个孩子的任何复合表达式），并->1说“替换为1”。

Python 2中，149个 139字节

10个字节感谢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个字节

EZqGYfy&mt2\Eq+)p

在线尝试！

说明

这不会直接使用指数。相反，它将每个（可能重复的）素数因子交换为下一个或前一个素数。

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

朱莉娅，64字节

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

在线尝试！最后一个测试用例需要太多的内存用于TIO，但是我已经在本地进行了验证。

怎么运行的

为了避免特殊壳体输入1 -没有定义空的字典的产物-我们乘输入Ñ通过2并通过其对划分的最终结果3。

factor(2n)给出素数为2n的所有正指数作为字典。遍历字典时，我们将获得键值/素数指数对。函数prod将采用这些对，将匿名函数t->...应用于它们，并返回结果的乘积。

对于每一对T =（P，E） ，endof(~t[1])或endof(primes(t[1]))返回ķ，是小于或等于质数的数p意味着，p是ķ ^个素数。

+1$1-1会将k，XOR k +1加1并减少结果。如果k为奇数，则k + 1为偶数，因此XOR递增，最终结果为k + 1。如果k为偶数，则k +1为奇数，因此XOR递减，最终结果为k-1。

最后，我们使用或来计算所有小于或等于3n的素数（如果n> 2，则最大素数2n小于或等于n，并且n和2n之间始终存在素数），选择索引k + 1或的k - 1，并将其提升到è ^个功率。(~3n)primes(3n)^t[2]

Python 2，112 109 108 95 94字节

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])

在Ideone上进行测试。

怎么运行的

当˚F被调用时，它首先计算1 / N。如果结果不为零，则n为1，f返回1。

如果n> 1，则会发生以下情况。

• 如果n不能被p [1]（最初为2）整除，则n%p[1]得出真实值，并且

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

  被叫。

  该分支生成质数，直到倒数第二个整数除以n为止。为此，它使用了威尔逊定理的以下推论。

  

  在任何时候，m都等于k-1的阶乘（最初是6 = 3！和4）。在每次迭代中，的结果m*m%k*[k]都优先于质数p的列表。根据推论，如果k为质数，m*m%k则结果为1。0如果没有，所以这种预规划ķ到p当且仅当ķ是素数。

• 如果n可被p [1]整除，则n%p[1]产生0和

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

  被执行。

  如果p包含偶数个质数，len(p)*2%4将产生0，并且第一个被乘数取p [0]的值。如果p包含奇数个质数，len(p)*2%4将得出2，并且第一个被乘数取p [2]的值。

  无论哪种情况，这都是素数，其指数必须与p [1]的素数交换，因此我们将n除以p [1]（将指数减1），然后将结果乘以f(n/p[1])相应的素数（增加1的指数）。

  请注意，将k，m和pf(n/p[1])重置为其默认值。会提高效率，但要多花六个字节。f(n/p[1],k,m,p)

Pyth，25个字节

JfP_TSfP_ThQ*F+1m@Jx1xJdP

测试套件。

说明

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

朱莉娅155个 131 127字节

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)]))

这是一个接受整数并返回整数的匿名函数。要调用它，请将其分配给变量。它要求Julia版本<0.5，因为主要功能已从0.5中的Base中删除。

取消高尔夫：

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

在线尝试！（包括所有测试用例）

实际上是15个字节

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

在线尝试！

说明：

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字节

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

解释

Ó¾‚˜                    # 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

在线尝试

J，21个字节

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

获取n的质数指数作为零的质数幂。然后将它们划分为大小为2的非重叠子列表，同时填充额外的零。然后反转每个子列表，并将它们展平到一个列表中。最后，将质数指数转换回数字。

用法

   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

说明

([:,_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