Cách hiệu quả nhất để thực hiện hàm pow dựa trên số nguyên (int, int)

Cách hiệu quả nhất được đưa ra để nâng một số nguyên lên sức mạnh của một số nguyên khác trong C là gì?

// 2^3
pow(2,3) == 8

// 5^5
pow(5,5) == 3125

Lũy thừa bằng bình phương.

int ipow(int base, int exp)
{
    int result = 1;
    for (;;)
    {
        if (exp & 1)
            result *= base;
        exp >>= 1;
        if (!exp)
            break;
        base *= base;
    }

    return result;
}

Đây là phương pháp tiêu chuẩn để thực hiện lũy thừa mô-đun cho số lượng lớn trong mật mã bất đối xứng.

Lưu ý rằng lũy thừa bằng bình phương không phải là phương pháp tối ưu nhất. Đây có thể là cách tốt nhất bạn có thể làm như một phương pháp chung hoạt động cho tất cả các giá trị số mũ, nhưng đối với một giá trị số mũ cụ thể, có thể có một chuỗi tốt hơn cần ít phép nhân hơn.

Chẳng hạn, nếu bạn muốn tính x ^ 15, phương pháp lũy thừa bằng bình phương sẽ cho bạn:

x^15 = (x^7)*(x^7)*x 
x^7 = (x^3)*(x^3)*x 
x^3 = x*x*x

Đây là tổng cộng 6 phép nhân.

Hóa ra điều này có thể được thực hiện bằng cách sử dụng "chỉ" 5 phép nhân thông qua phép lũy thừa chuỗi bổ sung .

n*n = n^2
n^2*n = n^3
n^3*n^3 = n^6
n^6*n^6 = n^12
n^12*n^3 = n^15

Không có thuật toán hiệu quả để tìm chuỗi nhân tối ưu này. Từ Wikipedia :

Vấn đề tìm chuỗi bổ sung ngắn nhất không thể được giải quyết bằng lập trình động, bởi vì nó không thỏa mãn giả định về cấu trúc tối ưu. Đó là, không đủ để phân rã sức mạnh thành các sức mạnh nhỏ hơn, mỗi sức mạnh được tính toán tối thiểu, vì các chuỗi bổ sung cho các quyền lực nhỏ hơn có thể có liên quan (để chia sẻ tính toán). Ví dụ: trong chuỗi bổ sung ngắn nhất cho a¹⁵ ở trên, bài toán con cho a⁶ phải được tính là (a³) ² vì a³ được sử dụng lại (trái ngược với, a = a² (a²) ², cũng cần ba bội số ).

Nếu bạn cần nâng 2 lên một sức mạnh. Cách nhanh nhất để làm như vậy là thay đổi bit theo sức mạnh.

2 ** 3 == 1 << 3 == 8
2 ** 30 == 1 << 30 == 1073741824 (A Gigabyte)

Đây là phương thức trong Java

private int ipow(int base, int exp)
{
    int result = 1;
    while (exp != 0)
    {
        if ((exp & 1) == 1)
            result *= base;
        exp >>= 1;
        base *= base;
    }

    return result;
}

int pow( int base, int exponent)

{   // Does not work for negative exponents. (But that would be leaving the range of int) 
    if (exponent == 0) return 1;  // base case;
    int temp = pow(base, exponent/2);
    if (exponent % 2 == 0)
        return temp * temp; 
    else
        return (base * temp * temp);
}

Nếu bạn muốn lấy giá trị của một số nguyên cho 2 tăng lên sức mạnh của thứ gì đó thì tốt hơn là sử dụng tùy chọn thay đổi:

pow(2,5) có thể được thay thế bởi 1<<5

Điều này là hiệu quả hơn nhiều.

power()Chức năng chỉ hoạt động cho Số nguyên

int power(int base, unsigned int exp){

    if (exp == 0)
        return 1;
    int temp = power(base, exp/2);
    if (exp%2 == 0)
        return temp*temp;
    else
        return base*temp*temp;

}

Độ phức tạp = O (log (exp))

power()Chức năng làm việc cho exp âm và cơ sở float .

float power(float base, int exp) {

    if( exp == 0)
       return 1;
    float temp = power(base, exp/2);       
    if (exp%2 == 0)
        return temp*temp;
    else {
        if(exp > 0)
            return base*temp*temp;
        else
            return (temp*temp)/base; //negative exponent computation 
    }

} 

Độ phức tạp = O (log (exp))

Một trường hợp cực kỳ đặc biệt là, khi bạn cần nói 2 ^ (- x với y), trong đó x, tất nhiên là âm và y quá lớn để thực hiện dịch chuyển trên một int. Bạn vẫn có thể thực hiện 2 ^ x trong thời gian liên tục bằng cách bắt vít bằng phao.

struct IeeeFloat
{

    unsigned int base : 23;
    unsigned int exponent : 8;
    unsigned int signBit : 1;
};


union IeeeFloatUnion
{
    IeeeFloat brokenOut;
    float f;
};

inline float twoToThe(char exponent)
{
    // notice how the range checking is already done on the exponent var 
    static IeeeFloatUnion u;
    u.f = 2.0;
    // Change the exponent part of the float
    u.brokenOut.exponent += (exponent - 1);
    return (u.f);
}

Bạn có thể nhận được nhiều quyền hạn hơn bằng cách sử dụng gấp đôi làm loại cơ sở. (Cảm ơn rất nhiều đến những người bình luận đã giúp bình phương bài này đi).

Ngoài ra còn có khả năng tìm hiểu thêm về phao của IEEE , các trường hợp lũy thừa đặc biệt khác có thể xuất hiện.

Cũng như theo dõi để nhận xét về hiệu quả của lũy thừa bằng cách bình phương.

Ưu điểm của phương pháp đó là nó chạy trong thời gian log (n). Ví dụ: nếu bạn định tính toán một cái gì đó rất lớn, chẳng hạn như x ^ 1048575 (2 ^ 20 - 1), bạn chỉ phải thực hiện vòng lặp 20 lần chứ không phải 1 triệu + bằng cách sử dụng phương pháp ngây thơ.

Ngoài ra, về độ phức tạp của mã, đơn giản hơn là cố gắng tìm chuỗi nhân tối ưu nhất, một gợi ý của la Pramod.

Biên tập:

Tôi đoán tôi nên làm rõ trước khi ai đó gắn thẻ cho tôi về khả năng tràn. Cách tiếp cận này giả định rằng bạn có một số loại thư viện khổng lồ.

Đi dự tiệc muộn:

Dưới đây là một giải pháp cũng giải quyết y < 0tốt nhất có thể.

1. Nó sử dụng một kết quả của intmax_tphạm vi tối đa. Không có quy định cho câu trả lời không phù hợp vớiintmax_t .
2. powjii(0, 0) --> 1đó là một kết quả phổ biến cho trường hợp này.

3. pow(0,negative), một kết quả không xác định khác, trả về INTMAX_MAX

   intmax_t powjii(int x, int y) {
     if (y < 0) {
       switch (x) {
         case 0:
           return INTMAX_MAX;
         case 1:
           return 1;
         case -1:
           return y % 2 ? -1 : 1;
       }
       return 0;
     }
     intmax_t z = 1;
     intmax_t base = x;
     for (;;) {
       if (y % 2) {
         z *= base;
       }
       y /= 2;
       if (y == 0) {
         break; 
       }
       base *= base;
     }
     return z;
   }

Mã này sử dụng một vòng lặp mãi mãi for(;;)để tránh điểm chung cuối cùng base *= basetrong các giải pháp vòng lặp khác. Phép nhân đó là 1) không cần thiết và 2) có thể bị int*inttràn đó là UB.

giải pháp chung hơn xem xét exponenet tiêu cực

private static int pow(int base, int exponent) {

    int result = 1;
    if (exponent == 0)
        return result; // base case;

    if (exponent < 0)
        return 1 / pow(base, -exponent);
    int temp = pow(base, exponent / 2);
    if (exponent % 2 == 0)
        return temp * temp;
    else
        return (base * temp * temp);
}

Thêm một triển khai (trong Java). Có thể không phải là giải pháp hiệu quả nhất nhưng # lần lặp lại giống như giải pháp theo cấp số nhân.

public static long pow(long base, long exp){        
    if(exp ==0){
        return 1;
    }
    if(exp ==1){
        return base;
    }

    if(exp % 2 == 0){
        long half = pow(base, exp/2);
        return half * half;
    }else{
        long half = pow(base, (exp -1)/2);
        return base * half * half;
    }       
}

Tôi sử dụng đệ quy, nếu exp là chẵn, 5 ^ 10 = 25 ^ 5.

int pow(float base,float exp){
   if (exp==0)return 1;
   else if(exp>0&&exp%2==0){
      return pow(base*base,exp/2);
   }else if (exp>0&&exp%2!=0){
      return base*pow(base,exp-1);
   }
}

Ngoài câu trả lời của Elias, nguyên nhân gây ra Hành vi không xác định khi được triển khai với số nguyên đã ký và giá trị không chính xác cho đầu vào cao khi được triển khai với số nguyên không dấu,

đây là phiên bản sửa đổi của lũy thừa theo bình phương cũng hoạt động với các kiểu số nguyên đã ký và không đưa ra các giá trị không chính xác:

#include <stdint.h>

#define SQRT_INT64_MAX (INT64_C(0xB504F333))

int64_t alx_pow_s64 (int64_t base, uint8_t exp)
{
    int_fast64_t    base_;
    int_fast64_t    result;

    base_   = base;

    if (base_ == 1)
        return  1;
    if (!exp)
        return  1;
    if (!base_)
        return  0;

    result  = 1;
    if (exp & 1)
        result *= base_;
    exp >>= 1;
    while (exp) {
        if (base_ > SQRT_INT64_MAX)
            return  0;
        base_ *= base_;
        if (exp & 1)
            result *= base_;
        exp >>= 1;
    }

    return  result;
}

Cân nhắc cho chức năng này:

(1 ** N) == 1
(N ** 0) == 1
(0 ** 0) == 1
(0 ** N) == 0

Nếu bất kỳ tràn hoặc gói sẽ diễn ra, return 0;

Tôi đã sử dụng int64_t , nhưng bất kỳ chiều rộng (đã ký hoặc không dấu) có thể được sử dụng với ít sửa đổi. Tuy nhiên, nếu bạn cần sử dụng loại số nguyên có chiều rộng không cố định, bạn sẽ cần thay đổi SQRT_INT64_MAXtheo (int)sqrt(INT_MAX)(trong trường hợp sử dụng int) hoặc một cái gì đó tương tự, cần được tối ưu hóa, nhưng nó xấu hơn và không phải là biểu thức hằng C. Ngoài ra, kết quả của sqrt()một kết quả intlà không tốt lắm vì có dấu phẩy động trong trường hợp một hình vuông hoàn hảo, nhưng như tôi không biết về bất kỳ triển khai nào INT_MAX- hay tối đa của bất kỳ loại nào - là một hình vuông hoàn hảo, bạn có thể sống với.

Tôi đã thực hiện thuật toán ghi nhớ tất cả các quyền hạn được tính toán và sau đó sử dụng chúng khi cần. Vì vậy, ví dụ x ^ 13 bằng (x ^ 2) ^ 2 ^ 2 * x ^ 2 ^ 2 * x trong đó x ^ 2 ^ 2 nó được lấy từ bảng thay vì tính toán lại một lần nữa. Điều này về cơ bản là thực hiện câu trả lời @Pramod (nhưng trong C #). Số lượng nhân cần thiết là Ceil (Log n)

public static int Power(int base, int exp)
{
    int tab[] = new int[exp + 1];
    tab[0] = 1;
    tab[1] = base;
    return Power(base, exp, tab);
}

public static int Power(int base, int exp, int tab[])
    {
         if(exp == 0) return 1;
         if(exp == 1) return base;
         int i = 1;
         while(i < exp/2)
         {  
            if(tab[2 * i] <= 0)
                tab[2 * i] = tab[i] * tab[i];
            i = i << 1;
          }
    if(exp <=  i)
        return tab[i];
     else return tab[i] * Power(base, exp - i, tab);
}

Trường hợp của tôi hơi khác một chút, tôi đang cố gắng tạo mặt nạ từ một sức mạnh, nhưng tôi nghĩ tôi sẽ chia sẻ giải pháp mà tôi tìm thấy bằng mọi cách.

Rõ ràng, nó chỉ hoạt động cho quyền hạn của 2.

Mask1 = 1 << (Exponent - 1);
Mask2 = Mask1 - 1;
return Mask1 + Mask2;

Trong trường hợp bạn biết số mũ (và nó là số nguyên) tại thời gian biên dịch, bạn có thể sử dụng các mẫu để hủy đăng ký vòng lặp. Điều này có thể được thực hiện hiệu quả hơn, nhưng tôi muốn chứng minh nguyên tắc cơ bản ở đây:

#include <iostream>

template<unsigned long N>
unsigned long inline exp_unroll(unsigned base) {
    return base * exp_unroll<N-1>(base);
}

Chúng tôi chấm dứt đệ quy bằng cách sử dụng một chuyên môn mẫu:

template<>
unsigned long inline exp_unroll<1>(unsigned base) {
    return base;
}

Số mũ cần được biết trong thời gian chạy,

int main(int argc, char * argv[]) {
    std::cout << argv[1] <<"**5= " << exp_unroll<5>(atoi(argv[1])) << ;std::endl;
}