פּראָדוקטן פון ריינדזשאַז אין אַ מענגע  


שוועריקייט לעוועל שווער
אָפט געבעטן אין אַקקאָליטע DE שאָ פרעעטשאַרגע גוגל SAP לאַבס סנאַפּדעאַל Times אינטערנעט
מענגע מאָדולאַר אַריטמעטיק אָנפֿרעג פּראָבלעם

פּראָבלעם סטאַטעמענט  

די פּראָבלעם "פּראָדוקטן פון ריינדזשאַז אין אַ מענגע" שטאַטן אַז איר באַקומען אַ ינטאַדזשער מענגע וואָס באַשטייט פון נומערן פון 1 צו n און q נומער פון פֿראגן. יעדער אָנפֿרעג כּולל די קייט. די פּראָבלעם ויסזאָגונג פרעגט צו געפֿינען די פּראָדוקט אין די געגעבן קייט אונטער מאָדולאָ M, וווּ m איז קיין הויפּט נומער.

בייַשפּיל  

arr[] = {1,2,3,4,5,6}

M = 131

Query = [1, 6], [2, 4]
65 24

דערקלערונג 

פון 1 צו 6, די פּראָדוקט פון די קייט איז 720 ווען מאָדולאָ איז געווענדט, עס בלייבט 65 און 24 בלייבט די זעלבע.

פּראָדוקטן פון ריינדזשאַז אין אַ מענגע

צוגאַנג  

געגעבן אַ קייט פון אַ נומער ווי אַ סטאַרטינג נומער און אַ סאָף נומער. באטראכט דעם קייט ווי עס איז אָנגעפילט מיט אַלע די צווישן נומערן. אונדזער אַרבעט איז צו געפֿינען די נומער פון נומערן אין דעם קייט. מיר וועלן קאַלקיאַלייטינג די פּראָדוקט און די פאַרקערט פּראָדוקט, און שפּעטער, מיר וועלן סאָלווע די אָנפֿרעג, מיט דעם, צוויי סטעפּס פון קאַלקיאַלייטינג פאַר-פּראָדוקט און פאַרקערט פּראָדוקט, מיר וועלן סאָלווע קייפל פֿראגן אין אַ צייַט, מיר טאָן ניט ' איר דאַרפֿן צו דורכגיין אַ גאַנץ אַלגערידאַם צו סאָלווע אַ אָנפֿרעג.

ערשטער, רעכענען די פאַר-פּראָדוקט פון די מענגע, דאָס איז, מיר האָבן צו פאָרן די מענגע, און ערשטער פון אַלע, מיר דאַרפֿן צו צייכענען דעם ערשטן עלעמענט פון דער געגעבן מענגע צו דער ערשטער עלעמענט פון דער פאַר-פּראָדוקט מענגע. מיר וועלן דורכגיין די מענגע פֿון דער ערשטער שטעלע פון ​​דער געגעבן מענגע און קראָם די פּראָדוקט פון די פריערדיקע עלעמענט פון די געגעבן מענגע און די פּראָדוקט מענגע. צו האַלטן די מאָדולאָ, מיר וועלן זיין סטאָרד די מאָדולאָ פון די פּראָדוקט מיר באַקומען. און קראָם עס צו די פּראָדוקט מענגע.

זע אויך
לענג פון לאָנגעסט Fibonacci סובסעקווענסע

אין דער ווייַטער שריט, מיר וועלן רעכענען די פאַרקערט פּראָדוקט, מיט דעם, מיר מיינען די פאַרקערט פּראָדוקט פון די קייט, אַזוי אַז אויב מיר רעכענען די פאַרקערט פּראָדוקט ביז די ייט אינדעקס, די פאַרקערט פּראָדוקט איז די פּראָדוקט פון אַלע די נומערן פון די קייט 0 צו איך. מיט דעם, מיר קענען סאָלווע די אָנפֿרעג אין קעסיידערדיק צייט. מיר טאָן ניט דאַרפֿן צו מאַכן עקסטרע השתדלות פֿאַר סאַלווינג יעדער אָנפֿרעג. איצט אויב מיר באַקומען די אָנפֿרעג צו סאָלווע, מיר נאָר ווייַזן די פּראָדוקט פון פּרעפּראָדוקט [רעכט] און פּרעינווערסעפּראָדוקט [לינקס -1]. דאָס וועט זיין די פארלאנגט ענטפער.

קאָדעקס  

C ++ קאָד צו געפֿינען פּראָדוקטן פון ריינדזשאַז אין אַ מענגע

#include <iostream>
using namespace std;
#define MAX 100

int PreProductArray[MAX];
int PreInverseProduct[MAX];

int InverseP(int a, int modulo)
{
    int mP = modulo, temp, quotient;
    int xP = 0, x = 1;

    if (modulo == 1)
        return 0;

    while (a > 1)
    {
        quotient = a / modulo;

        temp = modulo;

        modulo = a % modulo;
        a = temp;

        temp = xP;

        xP = x - quotient * xP;

        x = temp;
    }
    if (x < 0)
        x += mP;

    return x;
}

void calculatePreProduct(int A[], int N, int P)
{
    PreProductArray[0] = A[0];

    for (int i = 1; i < N; i++)
    {
        PreProductArray[i] = PreProductArray[i - 1] *A[i];

        PreProductArray[i] = PreProductArray[i] % P;
    }
}
void calculatePreInverseProduct(int A[], int N, int P)
{
    PreInverseProduct[0] = InverseP(PreProductArray[0], P);

    for (int i = 1; i < N; i++)
        PreInverseProduct[i] = InverseP(PreProductArray[i], P);
}
int calculateProduct(int A[], int L, int R, int P)
{
    L = L - 1;
    R = R - 1;
    int ans;

    if (L == 0)
        ans = PreProductArray[R];
    else
        ans = PreProductArray[R] *
              PreInverseProduct[L - 1];

    return ans;
}

int main()
{
    int Arr[] = { 1, 2, 3, 4, 5, 6 };

    int N = sizeof(Arr) / sizeof(Arr[0]);

    int Modulo = 131;
    calculatePreProduct(Arr, N, Modulo);
    calculatePreInverseProduct(Arr, N, Modulo);

    int Left = 1, Right = 6;
    cout << calculateProduct(Arr, Left, Right, Modulo) << endl;

    Left = 2, Right = 4;
    cout << calculateProduct(Arr, Left, Right, Modulo)
         << endl;
    return 0;
}
65
24

Java קאָד צו געפֿינען פּראָדוקטן פון ריינדזשאַז אין אַ מענגע

class ProductInRange
{

    static int MAX = 100;
    static int PreProductArray[] = new int[MAX];
    static int PreInverseProduct[] = new int[MAX];

    static int InverseP(int a, int modulo)
    {
        int mP = modulo, temp, quotient;
        int xP = 0, x = 1;

        if (modulo == 1)
            return 0;

        while (a > 1)
        {
            quotient = a / modulo;

            temp = modulo;

            modulo = a % modulo;
            a = temp;

            temp = xP;

            xP = x - quotient * xP;

            x = temp;
        }
        if (x < 0)
            x += mP;

        return x;
    }
    
    static void calculatePreProduct(int A[], int N, int P)
    {
        PreProductArray[0] = A[0];

        for (int i = 1; i < N; i++)
        {
            PreProductArray[i] = PreProductArray[i - 1] *
                                 A[i];
            PreProductArray[i] = PreProductArray[i] % P;
        }
    }
    
    static void calculatePreInverseProduct(int A[], int N, int P)
    {
        PreInverseProduct[0] = InverseP(PreProductArray[0], P);

        for (int i = 1; i < N; i++)
            PreInverseProduct[i] = InverseP(PreProductArray[i],
                                            P);
    }
    
    static int calculateProduct(int A[], int L, int R, int P)
    {
        L = L - 1;
        R = R - 1;
        int ans;

        if (L == 0)
            ans = PreProductArray[R];
        else
            ans = PreProductArray[R] *
                  PreInverseProduct[L - 1];

        return ans;
    }
    
    public static void main(String[] args)
    {

        int Arr[] = { 1, 2, 3, 4, 5, 6 };

        int Modulo = 131;
        calculatePreProduct(Arr, Arr.length, Modulo);
        calculatePreInverseProduct(Arr, Arr.length,
                                   Modulo);
        int Left = 1, Right = 6;
        System.out.println(calculateProduct(Arr, Left,
                                            Right, Modulo));
        Left = 2;
        Right = 4;
        System.out.println(calculateProduct(Arr, Left,
                                            Right, Modulo));

    }
}
65
24

קאַמפּלעקסיטי אַנאַליסיס  

צייט קאַמפּלעקסיטי

אָ (N קלאָץ M + Q), דאָ, קלאָץ ב איז ווייַל פון דער פאַרקערט פּראָדוקט. דערנאָך אָ (ק) צו ענטפֿערן פֿראגן.

זע אויך
איין נומער

ספעיס קאַמפּלעקסיטי

אָ (N) ווו "N" איז די נומער פון עלעמענטן אין די מענגע. ווייַל מיר סטאָרד פאַר -פּראָדוקט און preProductInverse ערייז.