పూర్ణాంక లీట్‌కోడ్ పరిష్కారం యొక్క అంకెలు యొక్క ఉత్పత్తి మరియు మొత్తాన్ని తీసివేయండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది సిస్కో గూగుల్ ఉబెర్
మఠం

సమస్యల నివేదిక

ఈ సమస్యలో, అంకెల ఉత్పత్తికి మరియు ఇచ్చిన అంకెల మొత్తానికి మధ్య వ్యత్యాసాన్ని మనం కనుగొనాలి అనుకూల పూర్ణ సంఖ్య.

ఉదాహరణ

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.

అప్రోచ్

పూర్ణాంకం నుండి అంకెలను ఒక్కొక్కటిగా తీయగలిగితే కావలసిన అవుట్‌పుట్‌ను తిరిగి ఇవ్వడం సులభం అవుతుంది. '%' ఆపరేటర్‌ను ఉపయోగించడం ద్వారా దీన్ని సులభంగా చేయవచ్చు, ఎందుకంటే ”% 10” మనకు పూర్ణాంకం యొక్క చివరి అంకెను తెస్తుంది, అప్పుడు మనం దాని నుండి చివరి అంకెను పాప్ చేయడానికి పూర్ణాంకాన్ని 10 ద్వారా విభజించవచ్చు (మేము దీన్ని చేసినట్లు సమస్య). ఈ విధంగా, మేము ప్రతి అంకెను ప్రాసెస్ చేయవచ్చు మరియు ఉత్పత్తి మరియు మొత్తాన్ని కనుగొనవచ్చు. అప్పుడు, అవసరమైన ఫలితాన్ని పొందడానికి వాటి మధ్య వ్యత్యాసాన్ని మేము తిరిగి ఇవ్వగలము.

పూర్ణాంక లీట్‌కోడ్ పరిష్కారం యొక్క అంకెలు యొక్క ఉత్పత్తి మరియు మొత్తాన్ని తీసివేయండి

అల్గారిథం

  1. రెండు వేరియబుల్స్ ప్రారంభించండి, ఉత్పత్తి = 1 మరియు మొత్తం పూర్ణాంకం యొక్క ఉత్పత్తి మరియు అంకెల మొత్తాన్ని నిల్వ చేయడానికి = 0 N వరుసగా
  2. వరకు ఈ దశలను అనుసరించండి N> 0:
    1. N యొక్క చివరి అంకెను గుణించండి ఉత్పత్తి, ఉత్పత్తి * = N% 10
    2. N యొక్క చివరి అంకెను జోడించండి మొత్తం, sum + = 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

ఇంటీజర్ లీట్‌కోడ్ సొల్యూషన్ యొక్క అంకెలు యొక్క ఉత్పత్తి మరియు మొత్తాన్ని తీసివేయడం యొక్క సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

ఓ (లాగ్2N) మేము పూర్ణాంక N లోని ప్రతి అంకెకు లూప్ చేస్తున్నప్పుడు.

అంతరిక్ష సంక్లిష్టత

O (1) మేము స్థిరమైన మెమరీ స్థలాన్ని ఉపయోగిస్తున్నప్పుడు.