පූර්ණ සංඛ්‍යා ලීට්කෝඩ් විසඳුමක ඉලක්කම්වල නිෂ්පාදිතය සහ එකතුව අඩු කරන්න


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ සිස්කෝ ගූගල් Uber
ගණිතය

ගැටළු ප්රකාශය

මෙම ගැටළුව තුළ, ඉලක්කම්වල නිෂ්පාදිතය සහ දී ඇති ඉලක්කම්වල එකතුව අතර වෙනස අප විසින් සොයාගත යුතුය ධනාත්මක නිඛිල.

උදාහරණයක්

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” අපට නිඛිලයක අවසාන ඉලක්කම් ලබා දෙන බැවින්, අපට පූර්ණ සංඛ්‍යා XNUMX න් බෙදීමෙන් එයින් අවසන් ඉලක්කම් පිටතට ගෙන යා හැකිය (අප එය කළ ආකාරයට මෙය ගැටලුව). මේ ආකාරයෙන්, අපට එක් එක් ඉලක්කම් සැකසීමට සහ නිෂ්පාදිතය සහ එකතුව සොයාගත හැකිය. එවිට, අවශ්‍ය ප්‍රති .ලය ලබා ගැනීම සඳහා අපට ඔවුන් අතර වෙනස නැවත ලබා දිය හැකිය.

පූර්ණ සංඛ්‍යා ලීට්කෝඩ් විසඳුමක ඉලක්කම්වල නිෂ්පාදිතය සහ එකතුව අඩු කරන්න

ඇල්ගොරිතම

  1. විචල්යයන් දෙකක් ආරම්භ කරන්න, නිෂ්පාදන = 1 සහ මුදල = 0 නිඛිලවල නිෂ්පාදිතය සහ ඉලක්කම් එකතුව ගබඩා කිරීමට N පිළිවෙලින්
  2. තෙක් මෙම පියවර අනුගමනය කරන්න එන්> 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 හි සෑම ඉලක්කම් සඳහාම අපි ලූපයක් ලෙස.

අභ්‍යවකාශ සංකීර්ණතාව

ඕ (1) අපි නිරන්තර මතක අවකාශය භාවිතා කරන නිසා.