ਇੱਕ ਪੂਰਨ ਅੰਕ ਲੈਟਕੋਡ ਹੱਲ ਦੇ ਉਤਪਾਦ ਅਤੇ ਅੰਕ ਦਾ ਜੋੜ ਘਟਾਓ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਨੂੰ Cisco ਗੂਗਲ ਉਬੇਰ
ਗਣਿਤ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਇਸ ਸਮੱਸਿਆ ਵਿੱਚ, ਸਾਨੂੰ ਅੰਕ ਦੇ ਉਤਪਾਦ ਅਤੇ ਇੱਕ ਦਿੱਤੇ ਅੰਕ ਦੇ ਜੋੜ ਦੇ ਵਿਚਕਾਰ ਅੰਤਰ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਸਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ.

ਉਦਾਹਰਨ

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. ਦੇ ਅੰਤਮ ਅੰਕ ਨੂੰ ਗੁਣਾ ਕਰੋ ਉਤਪਾਦ, ਉਤਪਾਦ * = ਐਨ% 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) ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਇੱਕ ਪੂਰਨ ਅੰਕ N ਵਿਚ ਹਰੇਕ ਅੰਕ ਲਈ ਲੂਪ ਕਰਦੇ ਹਾਂ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (1) ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਨਿਰੰਤਰ ਮੈਮੋਰੀ ਸਪੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ.