( Bitleri komşularıyla değiştirmeyle ilgili sorumun takibi .)

Görev

Pozitif bir tamsayı verildiğinde x = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , art arda gelen her bir primer çifti için bu çarpanlara ayırmadaki üsleri değiştirerek elde edilen tamsayıyı yazdırın, y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) ·…

O0IS'de A061898 . Bu kod golf , bu yüzden en kısa program (bayt cinsinden) kazanır!

Test senaryoları

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

Jöle , 10 bayt

ÆE;0s2UFÆẸ

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

Jöle, 17 16 11 bayt

Dennis sayesinde 5 bayt.

ÆfÆC’^1‘ÆNP

Çevrimiçi deneyin!

açıklama

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

Önceki 16 baytlık sürüm

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

Çevrimiçi deneyin!

açıklama

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

Önceki 17 baytlık sürüm:

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

Çevrimiçi deneyin!

açıklama

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

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

Bir tamsayı alan ve döndüren adsız bir işlev. Girişe bir hata verir, 1ancak yine de doğru sonucu hesaplar.

açıklama

Her zamanki gibi, tüm sözdizimsel şeker nedeniyle, okuma sırası biraz komik. Bir &doğru tanımlayan bir isimsiz fonksiyonu ve argümanlar ile ifade edilir #, #2, #3vs.

...FactorInteger@#...

Girdiyi çarpanlarına ayırarak başlıyoruz. Bu, {prime, exponent}giriş 12verir gibi bir çift ​​listesi verir {{2, 2}, {3, 1}}. Biraz rahatsız edici, 1verir {{1, 1}}.

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

Bu , soldaki işlevi 1. düzeydeki tamsayılar listesine uygular , yani işlev her çift için çağrılır, asal ve üssü ayrı bağımsız değişkenler olarak iletir ve sonuçların bir listesini döndürür. (Bu, işlevi liste üzerinde eşlemeye benzer, ancak iki ayrı bağımsız değişken almak bir çift almaktan daha uygundur.)

...PrimePi@#...

Yerleşik kullanarak (asal) girdiye kadar olan ve dahil olan prim sayısını hesaplıyoruz PrimePi. Bu bize asalın indeksini verir.

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

Sonuç artar, XOR'lu hale getirilir 1ve tekrar azaltılır. Bu 1 <-> 2, 3 <-> 4, 5 <-> 6, ..., yani tüm 1 tabanlı endeksleri değiştirir. Giriş bu Not 1verecektir 0için PrimePidaha sonra bu eşleştirilir -1, bu işlemde. Bununla daha sonra ilgileneceğiz.

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

Şimdi n. Üssü elde ediyoruz (burada n , bir önceki hesaplamadan elde edilen sonuçtur). Bu noktada Prime[-1]bir hata atar, ancak değerlendirmeden kendini döndürür. Bu durumda güç, şu 1ana kadar tüm işlemin {Prime[-1]}girdi 1ve diğer tüm girdiler için doğru ana güçlerin bir listesi olmasını sağlar.

 1##&@@...

Sonra, tüm ana güçleri çoğaltırız. 1##&işlevi için standart bir golf hüneridir Times. Bkz bu ipucunu nasıl çalıştığını için (bölüm "argümanların Diziler").

Son olarak, 1yukarıdakilerin hepsiyle sonuçlanan girdilere dikkat etmeliyiz Prime[-1]. Bunu basit bir değiştirme kuralıyla kolayca düzeltebiliriz. Bunun f@xkısa olduğunu unutmayın f[x]. Sadece bu formun herhangi bir ifadesini eşleştirmek istiyoruz (çünkü diğer tüm sonuçlar tamsayı olacak, yani atom ifadeleri) ve yerine bir 1:

.../._@_->1

Burada, /.kısaltması ReplaceAll, _@_formun her şey için bir kalıptır f[x](tek çocukla yani herhangi bileşik ifade) ve ->1"ile değiştir diyor 1".

Python 2, 149139 bayt

Dennis sayesinde 10 bayt.

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 bayt

EZqGYfy&mt2\Eq+)p

Çevrimiçi deneyin!

açıklama

Bu, üsleri doğrudan kullanmaz. Bunun yerine, her (muhtemelen tekrarlanan) asal çarpanı bir sonraki veya bir önceki asal ile değiştirir.

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 bayt

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

Çevrimiçi deneyin! Son test durumu TIO için çok fazla bellek gerektiriyor, ancak yerel olarak doğruladım.

Nasıl çalışır

Özel mahfaza girişi önlemek için 1 biz çarpma girişi - boş sözlük ürün tanımlanmamıştır - N ile 2 ve çift nihai sonucu bölmek 3 .

factor(2n)sözlük olarak 2n'lik asal faktörlerin tüm pozitif üslerini verir . Sözlüğü tekrarlarken, anahtar / değer / üs-üst çiftlerini alırız. İşlev prodbu çiftleri alacak, anonim işlevi t->...onlara uygulayacak ve sonuçların ürününü döndürecektir.

Her bir çift için t = (p, d) , endof(~t[1])ya da endof(primes(t[1]))geri k , daha az ya da eşit asal sayısı p , yani p olan k ^inci asal.

+1$1-1artırır k , XOR k + 1 ile 1 ve sonucu azaltma. Eğer k garip, k + 1 XOR artışlarla ve nihai sonuç bu yüzden, hatta bir k + 1 . Eğer k bile olduğunu k + 1 XOR azalma oranlarının ve nihai sonucudur, bu yüzden garip 1 - k .

Son olarak, daha az asal sayıları hesaplamak veya eşit 3n ile (~3n)veya primes(3n)(en yüksek asal faktör 2n azdır veya hiç eşit n ise n> 2 ve aralarında her zaman bir asal var n ve 2n ), endeksi birer seçebilir k + 1 veya k - 1 ve bunu yükseltmek e ^inci ile güç ^t[2].

Piton 2, 112 109 108 95 94 bayt

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 üzerinde test edin .

Nasıl çalışır

Ne zaman f denir, ilk hesaplar n / 1 . Sonuç sıfır değilse, ise , n ise 1 ve f döner 1 .

Eğer n> 1 , şu olur.

• Eğer , n ile bölünebilir değildir , p [1] (başlangıçta 2 ), n%p[1]bir truthy değerini verir ve

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

  denir.

  Bu dal, sondan bir önceki n eşit olarak bölünene kadar asal sayı oluşturur . Bunu yapmak için, Wilson teoreminin aşağıdaki sonucunu kullanır .

  

  Her zaman, m faktöriyele eşittir k - 1 (başlangıçta = 3 6! Ve 4 her tekrarında, sonucu. m*m%k*[k]Asal listesine önüne alır p doğal sonucu olarak,. m*m%kİse 1 ise k asal olup 0 değilse, bu prepends yüzden k için p ancak ve ancak k bir asal sayıdır.

• Eğer , n bölünemeyen bir p [1] , n%p[1]verimleri 0 ve

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

  idam edilir.

  Eğer p asal sayılar da eşit miktarda içeren, len(p)*2%4verecektir 0 ve birinci çarpılan değerini alır , p [0] . Eğer p asal sayıların tek bir miktarda içerir, len(p)*2%4verecektir 2 ve birinci çarpılan değerini alır , p [2] .

  Her iki durumda da, bu olan üsler sahip biri ile değiştirilecek için asal p [1] biz bölmek, böylece n ile p [1] ile (üs azalan 1 ) ve çok-katlı sonucu f(n/p[1])uygun gelen asıl göre (artan üs 1 ).

  Not f(n/p[1])sıfırlar k , m ve p varsayılan değerlerine. f(n/p[1],k,m,p)altı baytlık bir maliyetle verimliliği artıracaktır.

Pyth, 25 bayt

JfP_TSfP_ThQ*F+1m@Jx1xJdP

Test odası.

açıklama

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 bayt

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

Bu, bir tamsayıyı kabul eden ve bir tam sayı döndüren anonim bir işlevdir. Bunu çağırmak için bir değişkene atayın. Bir julia sürümü <0.5 gerektirir çünkü ana işlevsellik 0.5'ten Base'den kaldırılmıştır.

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

Çevrimiçi deneyin! (Tüm test senaryolarını içerir)

Aslında 15 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Açıklaması

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

Çevrimiçi deneyin

J, 21 bayt

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

N'nin ana üslerini sıfırlarla ana güç olarak alır. Daha sonra, ekstra bir sıfır ile doldururken bunları boyut 2'deki örtüşmeyen alt listelere bölün. Sonra her bir alt listeyi ters çevirin ve bir listeye düzleştirin. Son olarak, ana üslerden bir sayıya geri dönün.

kullanım

   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

açıklama

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