(Seguito della mia domanda sullo scambio di bit con i loro vicini .)

Compito

Dato un numero intero positivo x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , stampa il numero intero ottenuto scambiando gli esponenti in questa fattorizzazione per ciascuna coppia successiva di numeri primi, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

A061898 nell'OEIS. Questo è code-golf , quindi vince il programma più breve (in byte)!

Casi test

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

Gelatina , 10 byte

ÆE;0s2UFÆẸ

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Gelatina, 17 16 11 byte

5 byte grazie a Dennis.

ÆfÆC’^1‘ÆNP

Provalo online!

Spiegazione

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

Versione precedente a 16 byte

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

Provalo online!

Spiegazione

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

Versione precedente a 17 byte:

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

Provalo online!

Spiegazione

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

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

Una funzione senza nome che accetta e restituisce un numero intero. Genera un errore sull'input 1ma calcola comunque il risultato corretto.

Spiegazione

Come al solito, a causa di tutto lo zucchero sintattico, l'ordine di lettura è un po 'divertente. Un &sui definisce giuste una funzione senza nome e suoi argomenti sono indicati da #, #2, #3, etc.

...FactorInteger@#...

Iniziamo prendendo in considerazione l'input. Questo dà una lista di coppie {prime, exponent}es ingresso 12dà {{2, 2}, {3, 1}}. In qualche modo in modo inopportuno, 1dà {{1, 1}}.

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

Questo applica la funzione a sinistra all'elenco di numeri interi al livello 1, ovvero la funzione viene chiamata per ogni coppia, passando il primo e l'esponente come argomenti separati, quindi restituisce un elenco dei risultati. (Questo è simile al mapping della funzione sull'elenco, ma ricevere due argomenti separati è più conveniente che ricevere una coppia.)

...PrimePi@#...

Calcoliamo il numero di numeri primi fino a, incluso l'ingresso (primo) incluso, utilizzando l'integrato PrimePi. Questo ci dà l'indice del numero primo.

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

Il risultato viene incrementato, XOR con 1e nuovamente diminuito. Questo scambia 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., cioè tutti gli indici basati su 1. Si noti che l'input 1produrrà 0per PrimePicui viene quindi mappato -1in questo processo. Ci occuperemo più tardi.

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

Ora ottiene il n ° primo (dove n è il risultato del calcolo precedente), che è il primo correttamente scambiati, ed innalziamola alla potenza del primo originale nel fattorizzazione dell'ingresso. A questo punto Prime[-1]verrà generato un errore ma verrà restituito non valutato. La potenza in questo caso è 1che l'intero processo finora produce {Prime[-1]}input 1e un elenco di potenze primi corrette per tutti gli altri input.

 1##&@@...

Successivamente, moltiplichiamo semplicemente tutti i poteri principali. 1##&è un trucco da golf standard per la Timesfunzione. Vedi questo suggerimento (sezione "Sequenze di argomenti") per come funziona.

Infine, dobbiamo occuparci degli input 1per i quali tutto quanto sopra è risultato Prime[-1]. Possiamo facilmente risolverlo con una semplice regola di sostituzione. Ricorda che f@xè l'abbreviazione di f[x]. Vogliamo solo abbinare qualsiasi espressione di quella forma (poiché tutti gli altri risultati saranno numeri interi, cioè espressioni atomiche), e sostituirlo con un 1:

.../._@_->1

Qui, /.è l'abbreviazione di ReplaceAll, _@_è un modello per qualsiasi forma f[x](cioè qualsiasi espressione composta con un singolo figlio) e ->1dice "sostituisci con 1".

Python 2, 149 139 byte

10 byte grazie 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 byte

EZqGYfy&mt2\Eq+)p

Provalo online!

Spiegazione

Questo non usa direttamente gli esponenti. Invece, scambia ogni fattore primo (eventualmente ripetuto) con il primo successivo o precedente.

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

Provalo online! L'ultimo test case richiede troppa memoria per TIO, ma l'ho verificato localmente.

Come funziona

Per evitare l'input di maiuscole / minuscole 1 - il prodotto di un dizionario vuoto non è definito - moltiplichiamo l'input n per 2 e dividiamo il risultato finale per la sua coppia 3 .

factor(2n)fornisce tutti gli esponenti positivi dei fattori primi di 2n come dizionario. Quando si scorre il dizionario, si ottengono coppie chiave-valore / esponente principale. La funzione prodprenderà queste coppie, applicherà loro la funzione anonima t->...e restituirà il prodotto dei risultati.

Per ogni coppia t = (p, e) , endof(~t[1])o endof(primes(t[1]))restituisce k , il numero di numeri primi che sono minori o uguali a p , il che significa che p è il k ^° primo.

+1$1-1incrementerà k , XOR k + 1 con 1 e diminuirà il risultato. Se k è dispari, k + 1 è pari, quindi XOR aumenta e il risultato finale è k + 1 . Se k è pari, k + 1 è dispari, quindi XOR diminuisce e il risultato finale è k - 1 .

Infine, calcoliamo tutti i numeri primi minori o uguali a 3n con (~3n)o primes(3n)(il fattore primo più alto di 2n è minore o uguale a n se n> 2 , e c'è sempre un numero primo tra n e 2n ), selezioniamo quello all'indice k + 1 o k - 1 , ed elevarlo al di posta ^esima potenza con ^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])

Provalo su Ideone .

Come funziona

Quando viene chiamato f , prima calcola 1 / n . Se il risultato è diverso da zero, n è 1 e f restituisce 1 .

Se n> 1 , si verifica quanto segue.

• Se n non è divisibile per p [1] (inizialmente 2 ), n%p[1]produce un valore di verità e

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

  viene chiamato.

  Questo ramo genera un numero primo fino a quando il penultimo divide uniformemente n . Per fare ciò, utilizza il seguente corollario del teorema di Wilson .

  

  In ogni momento, m è uguale al fattoriale di k - 1 (inizialmente 6 = 3! E 4. In ogni iterazione, il risultato di m*m%k*[k]viene anteposto all'elenco dei numeri primi p . Per corollario, m*m%kè 1 se k è primo e 0 in caso contrario, quindi antepone k a p se e solo se k è un numero primo.

• Se n è divisibile per p [1] , n%p[1]produce 0 e

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

  viene eseguito.

  Se p contiene un numero pari di numeri primi, len(p)*2%4si ottiene 0 e il primo multiplicando assume il valore di p [0] . Se p contiene una quantità dispari di numeri primi, len(p)*2%4produrrà 2 e il primo multiplicando assume il valore di p [2] .

  In entrambi i casi, questo è il primo i cui esponenti devono essere scambiati con quello di p [1] , quindi dividiamo n per p [1] (diminuendo l'esponente per 1 ) e moltiplichiamo il risultato f(n/p[1])per il primo corrispondente (aumentando l'esponente di 1 ).

  Si noti che f(n/p[1])reimposta k , m e p ai valori predefiniti. f(n/p[1],k,m,p)migliorerebbe l'efficienza, al costo di sei byte extra.

Pyth, 25 byte

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Suite di test.

Spiegazione

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

Questa è una funzione anonima che accetta un numero intero e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile. Richiede una versione Julia <0,5 perché la funzionalità principale è stata rimossa da Base in 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

Provalo online! (Include tutti i casi di test)

In realtà, 15 byte

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

Provalo online!

Spiegazione:

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

spiegato

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

Provalo online

J, 21 byte

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

Ottiene gli esponenti primi di n come poteri primi con zeri. Quindi suddividili in elenchi non sovrapposti di dimensione 2 durante il riempimento con uno zero aggiuntivo. Quindi invertire ciascun elenco secondario e appiattirli in un elenco. Infine, converti indietro da esponenti primi in un numero.

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

Spiegazione

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