(Tindak lanjuti pertanyaan saya tentang bertukar bit dengan tetangga mereka .)

Tugas

Diberikan bilangan bulat positif x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , cetak bilangan bulat yang diperoleh dengan menukar eksponen dalam faktorisasi ini untuk setiap pasangan bilangan prima berturut-turut, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

A061898 di OEIS. Ini adalah kode-golf , jadi program terpendek (dalam byte) menang!

Uji kasus

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

Jelly , 10 byte

ÆE;0s2UFÆẸ

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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

5 byte berkat Dennis.

ÆfÆC’^1‘ÆNP

Cobalah online!

Penjelasan

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

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

Cobalah online!

Penjelasan

Æ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 17 byte sebelumnya:

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

Cobalah online!

Penjelasan

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

Fungsi tanpa nama yang mengambil dan mengembalikan integer. Itu melempar kesalahan pada input 1tetapi masih menghitung hasil yang benar.

Penjelasan

Seperti biasa, karena semua gula sintaksis, urutan bacaannya agak lucu. Sebuah &pada mendefinisikan kanan fungsi yang tidak disebutkan namanya dan argumen yang disebut dengan #, #2, #3, dll

...FactorInteger@#...

Kami mulai dengan memfaktorkan input. Ini memberikan daftar pasangan {prime, exponent}mis. Input 12memberi {{2, 2}, {3, 1}}. Agak nyaman, 1memberi {{1, 1}}.

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

Ini menerapkan fungsi di sebelah kiri ke daftar bilangan bulat di level 1, yaitu fungsi dipanggil untuk setiap pasangan, melewati bilangan prima dan eksponen sebagai argumen yang terpisah, dan kemudian mengembalikan daftar hasil. (Ini mirip dengan memetakan fungsi di atas daftar, tetapi menerima dua argumen terpisah lebih nyaman daripada menerima pasangan.)

...PrimePi@#...

Kami menghitung jumlah bilangan prima hingga dan termasuk input (prima) menggunakan built-in PrimePi. Ini memberi kita indeks prima.

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

Hasilnya bertambah, XOR'ed dengan 1dan dikurangi lagi. Ini swap 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., yaitu semua indeks berbasis 1. Perhatikan bahwa masukan 1akan menghasilkan 0untuk PrimePiyang kemudian dipetakan ke -1dalam proses ini. Kami akan mengatasinya nanti.

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

Kita sekarang mendapatkan perdana ke- n (di mana n adalah hasil dari perhitungan sebelumnya), yang merupakan perdana yang ditukar dengan benar, dan menaikkannya ke kekuatan prime asli dalam factorisation dari input. Pada titik ini Prime[-1]akan terjadi kesalahan tetapi akan kembali sendiri tidak dievaluasi. Kekuatan dalam hal ini adalah 1sehingga seluruh proses sejauh ini menghasilkan {Prime[-1]}input 1dan daftar kekuatan utama yang benar untuk semua input lainnya.

 1##&@@...

Selanjutnya, kita gandakan semua kekuatan utama. 1##&adalah trik golf standar untuk Timesfungsinya. Lihat tip ini (bagian "Urutan argumen") untuk cara kerjanya.

Akhirnya, kita perlu berhati-hati terhadap masukan 1yang menghasilkan semua hal di atas Prime[-1]. Kami dapat dengan mudah memperbaikinya dengan aturan penggantian yang sederhana. Ingat itu f@xkependekan dari f[x]. Kami hanya ingin mencocokkan ekspresi apa pun dari bentuk itu (karena semua hasil lainnya akan berupa bilangan bulat, yaitu ekspresi atomik), dan ganti dengan 1:

.../._@_->1

Di sini, /.kependekan dari ReplaceAll, _@_adalah pola untuk segala bentuk f[x](yaitu setiap ekspresi majemuk dengan anak tunggal) dan ->1mengatakan "ganti dengan 1".

Python 2, 149 139 byte

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

Cobalah online!

Penjelasan

Ini tidak menggunakan eksponen secara langsung. Alih-alih, ia menukar masing-masing (mungkin diulang) faktor prima dengan prima berikutnya atau sebelumnya.

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

Cobalah online!Kasing uji terakhir membutuhkan terlalu banyak memori untuk TIO, tetapi saya telah memverifikasi secara lokal.

Bagaimana itu bekerja

Untuk menghindari input casing khusus 1 - produk dari kamus kosong tidak ditentukan - kami mengalikan input n dengan 2 dan membagi hasil akhir dengan pasangannya 3 .

factor(2n)memberikan semua eksponen positif faktor prima 2n sebagai kamus. Saat beralih ke kamus, kita akan mendapatkan pasangan key-value / prime-eksponent. Fungsi prodakan mengambil pasangan ini, menerapkan fungsi anonim t->...kepada mereka dan mengembalikan produk dari hasil.

Untuk setiap pasangan t = (p, e) , endof(~t[1])atau endof(primes(t[1]))mengembalikan k , jumlah bilangan prima yang kurang atau sama dengan p , artinya p adalah ^bilangan prima k .

+1$1-1akan menambah k , XOR k +1 dengan 1 dan menurunkan hasilnya. Jika k adalah ganjil, k + 1 adalah genap, maka kenaikan XOR dan hasil akhirnya adalah k + 1 . Jika k adalah genap, k + 1 adalah ganjil, sehingga XOR menurun dan hasil akhirnya adalah k - 1 .

Akhirnya, kami menghitung semua bilangan prima kurang atau sama dengan 3n dengan (~3n)atau primes(3n)(faktor prima tertinggi 2n kurang atau sama dengan n jika n> 2 , dan selalu ada bilangan prima antara n dan 2n ), pilih satu di indeks k + 1 atau k - 1 , dan mengangkatnya ke e ^th daya dengan ^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])

Uji di Ideone .

Bagaimana itu bekerja

Ketika f dipanggil, ia pertama menghitung 1 / n . Jika hasilnya bukan nol, n adalah 1 dan f mengembalikan 1 .

Jika n> 1 , berikut ini terjadi.

• Jika n tidak habis dibagi dengan p [1] (awalnya 2 ), n%p[1]menghasilkan nilai kebenaran dan

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

  dipanggil.

  Cabang ini menghasilkan bilangan prima sampai yang kedua dari belakang membagi secara merata n . Untuk melakukannya, ia menggunakan wajar berikut dari teorema Wilson .

  

  Setiap saat, m sama dengan faktorial dari k - 1 (awalnya 6 = 3! Dan 4. Dalam setiap iterasi, hasil m*m%k*[k]akan ditambahkan ke daftar bilangan prima p . Dengan wajar, m*m%kadalah 1 jika k adalah prima dan 0 jika tidak, jadi ini menambahkan k ke p jika dan hanya jika k adalah bilangan prima.

• Jika n dapat dibagi dengan p [1] , n%p[1]hasilkan 0 dan

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

  dieksekusi.

  Jika p berisi jumlah bilangan prima yang genap, len(p)*2%4akan menghasilkan 0 dan multiplikasi pertama mengambil nilai p [0] . Jika p berisi jumlah ganjil dari bilangan prima, len(p)*2%4akan menghasilkan 2 dan multiplikasi pertama mengambil nilai p [2] .

  Dalam kedua kasus, ini adalah bilangan prima yang eksponennya harus ditukar dengan bilangan p [1] , jadi kami membagi n dengan p [1] (mengurangi eksponen dengan 1 ) dan mengalikan hasil f(n/p[1])dengan bilangan prima yang sesuai (meningkat eksponen dengan 1 ).

  Perhatikan bahwa f(n/p[1])me - reset k , m dan p ke nilai standarnya. f(n/p[1],k,m,p)akan meningkatkan efisiensi, dengan biaya enam byte tambahan.

Pyth, 25 byte

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Suite uji.

Penjelasan

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

Ini adalah fungsi anonim yang menerima integer dan mengembalikan integer. Untuk menyebutnya, tetapkan ke variabel. Itu memerlukan versi Julia <0,5 karena fungsionalitas utama telah dihapus dari Base di 0,5.

Tidak Disatukan:

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

Cobalah online! (Termasuk semua kasus uji)

Sebenarnya, 15 byte

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

Cobalah online!

Penjelasan:

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

Dijelaskan

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

Cobalah online

J, 21 byte

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

Mendapat eksponen utama dari n sebagai kekuatan utama dengan nol. Kemudian mempartisi mereka menjadi sublists nonoverlapping ukuran 2 sambil mengisi dengan nol tambahan. Kemudian balikkan setiap sublist, dan ratakan menjadi daftar. Akhirnya, konversikan kembali dari eksponen utama ke angka.

Pemakaian

   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

Penjelasan

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