(Seguimiento de mi pregunta sobre el intercambio de bits con sus vecinos ).

Tarea

Dado un entero positivo x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , imprima el entero obtenido intercambiando los exponentes en esta factorización para cada par sucesivo de primos, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

A061898 en el OEIS. Este es el código de golf , por lo que gana el programa más corto (en bytes).

Casos de prueba

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

Jalea , 10 bytes

ÆE;0s2UFÆẸ

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Jalea, 17 16 11 bytes

5 bytes gracias a Dennis.

ÆfÆC’^1‘ÆNP

Pruébalo en línea!

Explicación

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

Versión anterior de 16 bytes

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

Pruébalo en línea!

Explicación

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

Versión anterior de 17 bytes:

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

Pruébalo en línea!

Explicación

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

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

Una función sin nombre que toma y devuelve un entero. Lanza un error en la entrada 1pero aún calcula el resultado correcto.

Explicación

Como de costumbre, debido a todo el azúcar sintáctico, el orden de lectura es un poco divertido. A &sobre los define el bien una función sin nombre y sus argumentos son referidos por #, #2, #3, etc.

...FactorInteger@#...

Comenzamos factorizando la entrada. Esto da una lista de pares, {prime, exponent}por ejemplo, 12da entradas {{2, 2}, {3, 1}}. Algo inconveniente, 1da {{1, 1}}.

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

Esto aplica la función de la izquierda a la lista de enteros en el nivel 1, es decir, se llama a la función para cada par, pasando el primo y el exponente como argumentos separados, y luego devuelve una lista de los resultados. (Esto es similar a mapear la función sobre la lista, pero recibir dos argumentos separados es más conveniente que recibir un par).

...PrimePi@#...

Calculamos el número de primos hasta e incluyendo la entrada (primo) utilizando el incorporado PrimePi. Esto nos da el índice de la prima.

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

El resultado se incrementa, se XOR con 1y se vuelve a disminuir. Esto cambia 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., es decir, todos los índices basados ​​en 1. Tenga en cuenta que la entrada 1producirá 0para PrimePique luego se asigna a -1en este proceso. Nos ocuparemos de eso más tarde.

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

Ahora obtenemos el n º primer (donde n es el resultado del cálculo anterior), que es el primer intercambiado correctamente, y elevarlo a la potencia del primer original en la factorización de la entrada. En este punto Prime[-1]arrojará un error pero se devolverá sin evaluar. La potencia en este caso es 1para que todo el proceso hasta ahora produzca {Prime[-1]}entrada 1y una lista de potencias primarias correctas para todas las demás entradas.

 1##&@@...

Luego, simplemente multiplicamos todos los poderes primarios. 1##&Es un truco de golf estándar para la Timesfunción. Consulte este consejo (sección "Secuencias de argumentos") para ver cómo funciona.

Finalmente, debemos ocuparnos de los aportes 1para los que todo lo anterior resultó Prime[-1]. Podemos arreglarlo fácilmente con una simple regla de reemplazo. Recuerda que f@xes la abreviatura de f[x]. Solo queremos hacer coincidir cualquier expresión de esa forma (ya que todos los demás resultados serán enteros, es decir, expresiones atómicas), y reemplazarlo con un 1:

.../._@_->1

Aquí, /.es la abreviatura de ReplaceAll, _@_es un patrón para cualquier cosa de la forma f[x](es decir, cualquier expresión compuesta con un solo hijo) y ->1dice "reemplazar con 1".

Python 2, 149 139 bytes

10 bytes gracias a 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 bytes

EZqGYfy&mt2\Eq+)p

Pruébalo en línea!

Explicación

Esto no usa los exponentes directamente. En cambio, intercambia cada factor primo (posiblemente repetido) por el primo siguiente o el anterior.

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 bytes

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

Pruébalo en línea! El último caso de prueba requiere demasiada memoria para TIO, pero lo he verificado localmente.

Cómo funciona

Para evitar la entrada de carcasa especial 1 , el producto de un diccionario vacío no está definido, multiplicamos la entrada n por 2 y dividimos el resultado final por su par 3 .

factor(2n)da todos los exponentes positivos de factores primos de 2n como diccionario. Al iterar sobre el diccionario, obtendremos pares clave-valor / primo-exponente. La función prodtomará estos pares, les aplicará la función anónima t->...y devolverá el producto de los resultados.

Para cada par t = (p, e) , endof(~t[1])o endof(primes(t[1]))devuelve k , el número de primos que son menores o iguales a p , lo que significa que p es el k ^número primo.

+1$1-1incrementará k , XOR k + 1 con 1 y disminuirá el resultado. Si k es impar, k + 1 es par, por lo que el XOR aumenta y el resultado final es k + 1 . Si k es par, k + 1 es impar, entonces el XOR disminuye y el resultado final es k - 1 .

Por último, se calcula todos los números primos menores o iguales a 3n con (~3n)o primes(3n)(el principal factor más alto de 2n es menor o igual a n si n> 2 , y siempre hay un primo entre n y 2n ), seleccionamos el que está en el índice k + 1 o k - 1 , y elevarlo a la e ^ª poder con ^t[2].

Python 2, 112 109 108 95 94 bytes

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

Pruébelo en Ideone .

Cómo funciona

Cuando se llama f , primero calcula 1 / n . Si el resultado no es cero, n es 1 y f retornos 1 .

Si n> 1 , sucede lo siguiente.

• Si n no es divisible por p [1] (inicialmente 2 ), n%p[1]produce un valor verdadero y

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

  se llama.

  Esta rama genera un número primo hasta que el penúltimo divida uniformemente n . Para hacerlo, utiliza el siguiente corolario del teorema de Wilson .

  

  En todo momento, m es igual al factorial de k - 1 (inicialmente 6 = 3! Y 4. En cada iteración, el resultado de m*m%k*[k]se antepone a la lista de primos p . Por el corolario, m*m%kes 1 si k es primo y 0 si no, así que esto precede k a p si y solo si k es un número primo.

• Si n es divisible por p [1] , n%p[1]produce 0 y

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

  se ejecuta

  Si p contiene una cantidad par de números primos, len(p)*2%4dará 0 y el primer multiplicando toma el valor de p [0] . Si p contiene una cantidad impar de números primos,len(p)*2%4 dará 2 y el primer multiplicando toma el valor de p [2] .

  En cualquier caso, este es el primo cuyos exponentes deben intercambiarse con el de p [1] , por lo que dividimos n entre p [1] (disminuyendo el exponente por 1 ) y multiplicamos el resultado de f(n/p[1])por el primo correspondiente (aumentando el exponente por 1 ).

  Tenga en cuenta que f(n/p[1])restablece k , m y p a sus valores por defecto. f(n/p[1],k,m,p)mejoraría la eficiencia, a costa de seis bytes adicionales.

Pyth, 25 bytes

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Banco de pruebas.

Explicación

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 bytes

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

Esta es una función anónima que acepta un entero y devuelve un entero. Para llamarlo, asígnelo a una variable. Requiere una versión de Julia <0.5 porque la funcionalidad principal se ha eliminado de Base en 0.5.

Sin golf:

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

Pruébalo en línea! (Incluye todos los casos de prueba)

En realidad, 15 bytes

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

Pruébalo en línea!

Explicación:

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 bytes

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

Explicado

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

Pruébalo en línea

J, 21 bytes

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

Obtiene los exponentes primos de n como potencias primarias con ceros. Luego, divídalos en sublistas no superpuestas de tamaño 2 mientras se llena con un cero adicional. Luego invierta cada sublista y aplánelas en una lista. Finalmente, vuelva a convertir de exponentes primos a un número.

Uso

   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

Explicación

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