(Acompanhe a minha pergunta sobre a troca de bits com os vizinhos .)

Tarefa

Dado um número inteiro positivo x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , imprima o número inteiro obtido trocando os expoentes nessa fatoração por cada par sucessivo de números primos, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

A061898 no OEIS. Isso é código-golfe , então o programa mais curto (em bytes) vence!

Casos de teste

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

Gelatina , 10 bytes

ÆE;0s2UFÆẸ

Experimente online! ou verifique todos os casos de teste .

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

Geléia, 17 16 11 bytes

5 bytes graças a Dennis.

ÆfÆC’^1‘ÆNP

Experimente online!

Explicação

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

Versão anterior de 16 bytes

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

Experimente online!

Explicação

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

Versão anterior de 17 bytes:

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

Experimente online!

Explicação

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

Uma função sem nome que pega e retorna um número inteiro. Ele gera um erro na entrada, 1mas ainda calcula o resultado correto.

Explicação

Como de costume, devido a todo o açúcar sintático, a ordem de leitura é um pouco engraçada. Um &nos define certas uma função sem nome e os seus argumentos são referidas por #, #2, #3, etc.

...FactorInteger@#...

Começamos fatorando a entrada. Isso fornece uma lista de pares, {prime, exponent}por exemplo, a entrada 12fornece {{2, 2}, {3, 1}}. Um pouco inconveniente, 1dá {{1, 1}}.

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

Isso aplica a função à esquerda à lista de números inteiros no nível 1, ou seja, a função é chamada para cada par, passando o primo e o expoente como argumentos separados e, em seguida, retorna uma lista dos resultados. (Isso é semelhante ao mapeamento da função na lista, mas receber dois argumentos separados é mais conveniente do que receber um par.)

...PrimePi@#...

Calculamos o número de primos até e incluindo a entrada (prime) usando o built-in PrimePi. Isso nos dá o índice do primo.

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

O resultado é incrementado, XOR'ed com 1e decrementado novamente. Isso troca 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., ou seja, todos os índices baseados em 1. Observe que a entrada 1produzirá 0para a PrimePiqual é mapeada -1nesse processo. Nós vamos lidar com isso mais tarde.

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

Agora, obtemos o n- ésimo primo (onde n é o resultado da computação anterior), que é o primo corretamente trocado e o elevamos à potência do primo original na fatoração da entrada. Nesse ponto Prime[-1], lançará um erro, mas retornará sem ser avaliado. O poder nesse caso é 1que todo o processo até agora rende {Prime[-1]}entrada 1e uma lista de potências primárias corretas para todas as outras entradas.

 1##&@@...

Em seguida, apenas multiplicamos todos os poderes principais. 1##&é um truque de golfe padrão para a Timesfunção. Veja esta dica (seção "Sequências de argumentos") para saber como funciona.

Finalmente, precisamos cuidar das informações 1para as quais todas as opções acima resultaram Prime[-1]. Podemos consertar isso facilmente com uma regra de substituição simples. Lembre-se de que f@xé uma abreviação de f[x]. Apenas queremos corresponder a qualquer expressão dessa forma (já que todos os outros resultados serão inteiros, ou seja, expressões atômicas) e substituí-la por 1:

.../._@_->1

Aqui, /.abreviação de ReplaceAll, _@_é um padrão para qualquer coisa da forma f[x](ou seja, qualquer expressão composta com um único filho) e ->1diz "substituir por 1".

Python 2, 149 139 bytes

10 bytes graças 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

Experimente online!

Explicação

Isso não usa os expoentes diretamente. Em vez disso, alterna cada fator primo (possivelmente repetido) pelo primo seguinte ou pelo primo 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

Experimente online! O último caso de teste requer muita memória para o TIO, mas eu o verifiquei localmente.

Como funciona

Para evitar a entrada de caixa especial 1 - o produto de um dicionário vazio não está definido - multiplicamos a entrada n por 2 e dividimos o resultado final por seu par 3 .

factor(2n)fornece todos os expoentes positivos dos fatores primos de 2n como um dicionário. Ao iterar sobre o dicionário, obteremos pares de valor-chave / expoente principal. A função prodpegará esses pares, aplicará a função anônima t->...a eles e retornará o produto dos resultados.

Para cada par t = (p, e) , endof(~t[1])ou endof(primes(t[1]))retorno k , o número de números primos que são menores ou iguais a p , significando que p é o k- ^ésimo primo.

+1$1-1aumentará k , XOR k + 1 com 1 e diminuirá o resultado. Se k é ímpar, k + 1 é par, então o XOR é incrementado e o resultado final é k + 1 . Se k é par, k + 1 é ímpar, então o XOR diminui e o resultado final é k - 1 .

Por fim, computamos todos os números primos menores ou iguais a 3n com (~3n)ou primes(3n)(o fator primo mais alto de 2n é menor ou igual a n se n> 2 , e sempre há um primo entre n e 2n ), selecione aquele no índice k + 1 ou k - 1 , e elevá-lo ao e ^th poder com ^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])

Teste em Ideone .

Como funciona

Quando f é chamado, ele primeiro calcula 1 / n . Se o resultado for diferente de zero, n é 1 e f retornos 1 .

Se n> 1 , acontece o seguinte.

• Se n não for divisível por p [1] (inicialmente 2 ), n%p[1]gera um valor de verdade e

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

  é chamado.

  Este ramo gera número primo até que o penúltimo divida uniformemente n . Para isso, utiliza o seguinte corolário do teorema de Wilson .

  

  Em todo momento, m é igual ao fatorial de k - 1 (inicialmente 6 = 3! E 4. Em cada iteração, o resultado de m*m%k*[k]é anexado à lista de primos p . Pelo corolário, m*m%ké 1 se k é primo e 0 se não, então isso precede k a p se e somente se k for um número primo.

• Se n é divisível por p [1] , n%p[1]produz 0 e

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

  é executado.

  Se p contiver uma quantidade par de números primos, len(p)*2%4produzirá 0 e o primeiro multiplicando assumirá o valor de p [0] . Se p contiver uma quantidade ímpar de números primos, len(p)*2%4produzirá 2 e o primeiro multiplicando assume o valor de p [2] .

  Em qualquer um dos casos, este é o primo cujos expoentes precisam ser trocados com o de p [1] , então dividimos n por p [1] (diminuindo o expoente em 1 ) e multiplicamos o resultado f(n/p[1])pelo primo correspondente (crescente o expoente por 1 ).

  Observe que f(n/p[1])redefine k , m e p para seus valores padrão. f(n/p[1],k,m,p)melhoraria a eficiência, ao custo de seis bytes extras.

Pitão, 25 bytes

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Suíte de teste.

Explicação

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 é uma função anônima que aceita um número inteiro e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável. Requer uma versão Julia <0,5 porque a funcionalidade principal foi removida da Base no 0,5.

Ungolfed:

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

Experimente online! (Inclui todos os casos de teste)

Na verdade, 15 bytes

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

Experimente online!

Explicação:

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

Experimente online

J, 21 bytes

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

Obtém os principais expoentes de n como potências primárias com zeros. Em seguida, particione-as em sublistas não sobrepostas de tamanho 2 enquanto preenche um zero extra. Em seguida, inverta cada sub-lista e alise-as em uma lista. Por fim, converta novamente de expoentes primos para um 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

Explicação

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