પૂર્ણાંક લિટકોડ સોલ્યુશનના અંકોના ઉત્પાદન અને રકમનો બાદબાકી કરો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે સિસ્કો Google ઉબેર
મઠ

સમસ્યા નિવેદન

આ સમસ્યામાં, આપણે અંકોના ઉત્પાદન અને આપેલના અંકોના સરવાળો વચ્ચે તફાવત શોધવાની જરૂર છે હકારાત્મક પૂર્ણાંક.

ઉદાહરણ

1234
14

સમજૂતી: ઉત્પાદન = 4 * 3 * 2 * 1 = 24 અને સરવાળો = 4 + 3 + 2 + 1 = 10. તેથી, તફાવત 14 છે

2045
-11

સમજૂતી: ઉત્પાદન = 2 * 0 * 4 * 5 = 0 અને સરવાળો = 2 + 0 + 4 + 5 = 11. તેથી, તફાવત -11 છે.

અભિગમ

ઇચ્છિત આઉટપુટ પાછા આપવું સરળ બને છે જો આપણે પૂર્ણાંકોમાંથી એક પછી એક અંકો કા couldી શકીએ. આ '%' ઓપરેટરનો ઉપયોગ કરીને સરળતાથી કરી શકાય છે, કેમ કે "% 10" આપણને પૂર્ણાંકોનો છેલ્લો અંકો લાવે છે, તેથી આપણે પૂર્ણાંકને 10 દ્વારા વિભાજીત કરી શકીએ છીએ તેમાંથી છેલ્લા અંકો પ popપ કરી શકીએ છીએ (જેમ કે આપણે તેમાં કર્યું છે) સમસ્યા). આ રીતે, અમે દરેક અંકો પર પ્રક્રિયા કરી શકીએ છીએ અને ઉત્પાદન અને રકમ શોધી શકીએ છીએ. તે પછી, અમે જરૂરી પરિણામ મેળવવા માટે તેમની વચ્ચેનો તફાવત પાછા આપી શકીશું.

પૂર્ણાંક લિટકોડ સોલ્યુશનના અંકોના ઉત્પાદન અને રકમનો બાદબાકી કરો

અલ્ગોરિધમ

  1. બે ચલો પ્રારંભ કરો, ઉત્પાદન = 1 અને સરવાળો = 0 પૂર્ણાંકના ઉત્પાદન અને અંકનો સરવાળો N અનુક્રમે
  2. સુધી આ પગલાંને અનુસરો એન> 0:
    1. N થી છેલ્લા અંકનો ગુણાકાર કરો ઉત્પાદન, ઉત્પાદન * = એન% 10
    2. પર N નો છેલ્લો આંકડો ઉમેરો સરવાળો, સરવાળો = = એન% 10
    3. ભાગલા N 10 દ્વારા અંતિમ અંક છોડવા, એન / = 10
  3. રીટર્ન ઉત્પાદન - રકમ

પૂર્ણાંક લીટકોડ સોલ્યુશનના ઉત્પાદન અને બાદબાકીના અમલીકરણનો અમલ

સી ++ પ્રોગ્રામ

#include <bits/stdc++.h>
using namespace std;

int subtractProductAndSum(int n)
{
    int product = 1 , sum = 0;
    while(n > 0)
    {
        //n % 10 extracts the last digit out of N
        product *= (n % 10);
        sum += (n % 10);
        n /= 10;
    }
    return product - sum;
}

int main()
{
    int n = 1234;
    cout << subtractProductAndSum(n) << '\n';
    return 0;
}

જાવા પ્રોગ્રામ

class subtract_product_and_sum
{
    public static void main(String args[])
    {
        int n = 1234;
        System.out.println(subtractProductAndSum(n));
    }

    static int subtractProductAndSum(int n)
    {
        int product = 1 , sum = 0;
        while(n > 0)
        {
            //n % 10 extracts the last digit out of N
            product *= (n % 10);
            sum += (n % 10);
            n /= 10;
        }
        return product - sum;
    }
}
14

પૂર્ણાંક લિટકોડ સોલ્યુશનના ઉત્પાદન અને બાદબાકીના ગુણનું જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (લોગ2'N) આપણે પૂર્ણાંક એન માં દરેક અંકો માટે લૂપ કરીએ છીએ.

અવકાશ જટિલતા

ઓ (1) જેમકે આપણે સતત મેમરી જગ્યા વાપરીએ છીએ.