(ติดตามคำถามของฉันเกี่ยวกับการแลกเปลี่ยนบิตกับเพื่อนบ้าน )

งาน

รับจำนวนเต็มบวกx = (2 ^a  · 3 ^b ) · (5 ^c  · 7 ^d ) · (11 ^e  · 13 ^f ) ·… , พิมพ์จำนวนเต็มที่ได้รับโดยการสลับเลขชี้กำลังในการแยกตัวประกอบสำหรับแต่ละช่วงของคู่y = (2 ^b  · 3 ^a ) · (5 ^d  · 7 ^c ) · (11 ^f  · 13 ^e ) · ...

A061898ใน OEIS นี่คือโค้ดกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุด (เป็นไบต์) ชนะ!

กรณีทดสอบ

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

เยลลี่ 10 ไบต์

ÆE;0s2UFÆẸ

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

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

เยลลี่, 17 16 11 ไบต์

5 ไบต์ขอบคุณเดนนิส

ÆfÆC’^1‘ÆNP

ลองออนไลน์!

คำอธิบาย

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

เวอร์ชัน 16 ไบต์ก่อนหน้า

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

ลองออนไลน์!

คำอธิบาย

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

เวอร์ชัน 17 ไบต์ก่อนหน้า:

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

ลองออนไลน์!

คำอธิบาย

Æ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 ไบต์

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

ฟังก์ชันที่ไม่มีชื่อซึ่งรับและส่งคืนจำนวนเต็ม มันจะโยนข้อผิดพลาดในการป้อนข้อมูล1แต่ยังคงคำนวณผลลัพธ์ที่ถูกต้อง

คำอธิบาย

ตามปกติเนื่องจากน้ำตาลประโยคทั้งหมดลำดับการอ่านค่อนข้างตลก &บนขวากำหนดฟังก์ชั่นที่ไม่มีชื่อและข้อโต้แย้งที่มีการอ้างถึงโดย#, #2, #3ฯลฯ

...FactorInteger@#...

เราเริ่มต้นด้วยการแยกอินพุต นี้จะช่วยให้รายชื่อของคู่{prime, exponent}เช่นการป้อนข้อมูลให้12 {{2, 2}, {3, 1}}ค่อนข้างลำบาก, ให้1{{1, 1}}

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

นี่ใช้ฟังก์ชั่นทางด้านซ้ายไปยังรายการจำนวนเต็มที่ระดับ 1 นั่นคือฟังก์ชั่นนี้ถูกเรียกใช้สำหรับแต่ละคู่ผ่านไพรม์และเลขชี้กำลังในรูปแบบอาร์กิวเมนต์แยกต่างหากจากนั้นส่งกลับรายการผลลัพธ์ (สิ่งนี้คล้ายกับการทำแผนที่ฟังก์ชั่นเหนือรายการ แต่การรับอาร์กิวเมนต์สองตัวแยกกันนั้นสะดวกกว่าการรับคู่)

...PrimePi@#...

เราคำนวณจำนวน primes และรวมถึง (ที่สำคัญ) PrimePiการป้อนข้อมูลที่ใช้ในตัว สิ่งนี้ทำให้เรามีดัชนีของนายก

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

ผลลัพธ์จะเพิ่มขึ้น XOR'ed ด้วย1และลดลงอีกครั้ง การแลกเปลี่ยนนี้1 <-> 2, 3 <-> 4, 5 <-> 6, ...คือดัชนีทั้งหมดที่ใช้ 1 โปรดทราบว่าการป้อนข้อมูล1จะให้ผลผลิต0สำหรับPrimePiที่ถูกแมปแล้ว-1ในขั้นตอนนี้ เราจะจัดการกับมันในภายหลัง

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

ตอนนี้เราได้รับไพรเวตที่n (โดยที่nคือผลลัพธ์จากการคำนวณก่อนหน้านี้) ซึ่งเป็นไพรม์ที่สลับสับเปลี่ยนได้อย่างถูกต้องและยกระดับเป็นไพรม์ไพรม์ดั้งเดิมในการแยกตัวประกอบของอินพุต ณ จุดนี้Prime[-1]จะเกิดข้อผิดพลาด แต่จะคืนค่าตัวเองกลับคืนมา พลังงานในกรณีนี้คือ1เพื่อให้กระบวนการทั้งหมดจนได้{Prime[-1]}รับอินพุต1และรายการของพลังพิเศษที่ถูกต้องสำหรับอินพุตอื่น ๆ ทั้งหมด

 1##&@@...

ต่อไปเราจะเพิ่มพลังพิเศษทั้งหมด 1##&เป็นเคล็ดลับการเล่นกอล์ฟมาตรฐานสำหรับTimesฟังก์ชั่น ดูเคล็ดลับนี้ (ส่วน "ลำดับของอาร์กิวเมนต์") สำหรับวิธีการทำงาน

สุดท้ายเราจะต้องดูแลของการป้อนข้อมูลที่ทั้งหมดของผลดังกล่าวข้างต้น1 Prime[-1]เราสามารถแก้ไขได้อย่างง่ายดายด้วยกฎการเปลี่ยนง่าย ๆ โปรดจำไว้ว่าสั้นสำหรับf@x f[x]เราเพียงต้องการจับคู่นิพจน์ใด ๆ ของแบบฟอร์มนั้น (เนื่องจากผลลัพธ์อื่นทั้งหมดจะเป็นจำนวนเต็มเช่นนิพจน์อะตอมมิก) และแทนที่ด้วย a 1:

.../._@_->1

นี่/.เป็นชื่อสั้นReplaceAll, _@_เป็นรูปแบบอะไรของรูปแบบf[x](เช่นการแสดงออกของสารประกอบใด ๆ กับเด็กคนเดียว) และ->1บอกว่า "เปลี่ยน1"

Python 2, 149 139 ไบต์

10 ไบต์ขอบคุณเดนนิส

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 ไบต์

EZqGYfy&mt2\Eq+)p

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ไม่ได้ใช้เลขชี้กำลังโดยตรง แต่จะแลกเปลี่ยนปัจจัยสำคัญแต่ละตัว (อาจเกิดซ้ำ) โดยนายกคนถัดไปหรือนายกคนก่อน

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 ไบต์

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

ลองออนไลน์! กรณีทดสอบสุดท้ายต้องใช้หน่วยความจำมากเกินไปสำหรับ TIO แต่ฉันได้ตรวจสอบแล้วในเครื่อง

มันทำงานอย่างไร

เพื่อหลีกเลี่ยงการพิเศษปลอกอินพุต1 - สินค้าของพจนานุกรมที่ว่างเปล่าไม่ได้ถูกกำหนด - เราคูณอินพุตnโดย2และแบ่งผลสุดท้ายโดยคู่ของ3

factor(2n)ให้เลขชี้กำลังเชิงบวกทั้งหมดของปัจจัยหลัก2nเป็นพจนานุกรม เมื่อวนซ้ำในพจนานุกรมเราจะได้รับคู่คีย์ - ค่า / ไพร์ม exponent ฟังก์ชั่นprodจะใช้คู่เหล่านี้ใช้ฟังก์ชั่นที่ไม่ระบุชื่อt->...กับพวกเขาและส่งคืนผลิตภัณฑ์ของผลลัพธ์

สำหรับแต่ละคู่t = (พีอี) , endof(~t[1])หรือendof(primes(t[1]))ผลตอบแทนkจำนวนเฉพาะที่น้อยกว่าหรือเท่ากับPหมายความว่าหน้าเป็นk ^วันสำคัญ

+1$1-1จะเพิ่มค่าk , XOR k + 1ด้วย1และลดผลลัพธ์ ถ้าkเป็นเลขคี่, k + 1คือแม้ดังนั้นการเพิ่มขึ้นแฮคเกอร์และผลสุดท้ายคือk + 1 ถ้าkเป็นแม้กระทั่งk + 1เป็นเลขคี่ดังนั้น decrements แฮคเกอร์และผลสุดท้ายคือk - 1

ในที่สุดเราคำนวณจำนวนเฉพาะทั้งหมดน้อยกว่าหรือเท่ากับ3nด้วย(~3n)หรือprimes(3n)(ปัจจัยสำคัญสูงสุดของ2nน้อยกว่าหรือเท่ากับnถ้าn> 2และมีค่าเฉพาะระหว่างnและ2n ) เลือกหนึ่งที่ดัชนีk + 1หรือk - 1และยกระดับไปยังอี^TH^t[2]ไฟฟ้าที่มี

Python 2, 112 109 108 95 94 94 ไบต์

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

มันทำงานอย่างไร

เมื่อฉเรียกว่ามันเป็นครั้งแรกคำนวณ1 / n หากผลเป็นที่ไม่ใช่ศูนย์nคือ1และฉผลตอบแทน1

ถ้าn> 1สิ่งต่อไปนี้จะเกิดขึ้น

• ถ้าnไม่หารด้วยp [1] (ตอนแรก2 ), n%p[1]ให้ค่าความจริงและ

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

  ถูกเรียก

  สาขานี้สร้างจำนวนเฉพาะจนสุดท้ายหนึ่งหารn การทำเช่นนั้นจะใช้ข้อพิสูจน์ต่อไปของทฤษฎีบทของวิลสัน

  

  ตลอดเวลาmเท่ากับแฟคทอเรียลของk - 1 (เริ่มแรก6 = 3!และ4ในแต่ละการวนซ้ำผลลัพธ์ของการm*m%k*[k]ได้รับการรวมเข้ากับรายการ primes pโดยควันหลงm*m%kคือ1ถ้าkเป็นนายกและ0ถ้าไม่ใช่ดังนั้นสิ่งนี้จะเติมkถึงpถ้าหากkเป็นจำนวนเฉพาะ

• ถ้าnหารด้วยหน้า [1] , n%p[1]อัตราผลตอบแทน0และ

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

  ถูกประหารชีวิต

  ถ้าหน้ามีจำนวนแม้แต่ของตัวเลขที่สำคัญlen(p)*2%4จะให้ผลผลิต0และคูณแรกใช้เวลาค่าของหน้า [0] ถ้าหน้ามีจำนวนแปลกของตัวเลขที่สำคัญlen(p)*2%4จะให้ผลผลิต2และคูณแรกใช้เวลาค่าของหน้า [2]

  ในทั้งสองกรณีนี่คือนายกที่มีเลขชี้กำลังต้องสลับกับหนึ่งในp [1]ดังนั้นเราหารnด้วยp [1] (ลดเลขชี้กำลัง1ด้วย) และคูณผลลัพธ์ของf(n/p[1])นายกที่สอดคล้องกัน (เพิ่มขึ้น เลขชี้กำลัง1 )

  โปรดทราบว่าf(n/p[1])รีเซ็ตk , mและpเป็นค่าเริ่มต้น f(n/p[1],k,m,p)จะปรับปรุงประสิทธิภาพในราคาหกไบต์พิเศษ

Pyth, 25 ไบต์

JfP_TSfP_ThQ*F+1m@Jx1xJdP

ชุดทดสอบ

คำอธิบาย

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 ไบต์

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

นี่เป็นฟังก์ชั่นนิรนามที่รับจำนวนเต็มและคืนค่าจำนวนเต็ม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร มันต้องใช้รุ่น Julia <0.5 เพราะฟังก์ชั่นสำคัญถูกลบออกจากฐานใน 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

ลองออนไลน์! (รวมถึงกรณีทดสอบทั้งหมด)

ที่จริงแล้ว 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

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 ไบต์

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

อธิบาย

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

ลองออนไลน์

J, 21 ไบต์

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

รับค่า exponents ที่สำคัญของnในรูปของมหาอำนาจที่มีศูนย์ จากนั้นแบ่งพาร์ติชันเหล่านั้นให้เป็นรายการย่อยที่ไม่มีการเหลื่อมขนาด 2 ในขณะที่เติมศูนย์พิเศษ จากนั้นย้อนกลับแต่ละรายการย่อยและปรับให้เป็นรายการย่อย ในที่สุดแปลงกลับจากเลขชี้กำลังที่ต้องการเป็นจำนวน

การใช้

   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

คำอธิบาย

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