ශුන්‍ය නොවන පූර්ණ සංඛ්‍යා ලීට්කෝඩ් විසඳුමක එකතුවට පූර්ණ සංඛ්‍යා පරිවර්තනය කරන්න


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

ගැටළුව පූර්ණ සංඛ්‍යා දෙකේ එකතුවට පරිවර්තනය කරන්න ලීට්කෝඩ් විසඳුම ලබා දී ඇති කොටස කොටස් කරන්නැයි අපෙන් ඉල්ලා සිටියේය නිඛිල. දී ඇති නිඛිලය සංඛ්‍යා දෙකකට බෙදිය යුතුය. මෙම නිඛිල දෙක සඳහා සීමාවක් තිබේ. මෙම නිඛිල දෙකේ ඉලක්කම් 0 අඩංගු නොවිය යුතුය. වඩා හොඳ අවබෝධයක් සඳහා, අපි උදාහරණ කිහිපයක් දෙස බලමු.

ශුන්‍ය නොවන පූර්ණ සංඛ්‍යා ලීට්කෝඩ් විසඳුමක එකතුවට පූර්ණ සංඛ්‍යා පරිවර්තනය කරන්න

n = 2
[1,1]

පැහැදිලි කිරීම: නිමැවුමේ පූර්ණ සංඛ්‍යා දෙක 1 සහ 1. පූර්ණ සංඛ්‍යා එක සමාන විය හැකි නමුත් ඒවාට ඉලක්කම් 0 නොතිබිය යුතුය. ප්‍රතිදානයේ අවහිරතා සපුරාලයි. නිඛිල දෙකේම එකතුව ආදානයට සමාන වේ. මේ අනුව ප්‍රතිදානය නිවැරදි ය.

n = 1010
[11, 999]

පැහැදිලි කිරීම: නිඛිල දෙකේම එකතුව 1010 ට සමාන බැවින් ප්‍රතිදානය නිවැරදි වේ. තවද ඒවාට 0 ට සමාන ඉලක්කම් නොමැත.

ශුන්‍ය නොවන පූර්ණ සංඛ්‍යා ලීට්කෝඩ් විසඳුමක එකතුවට පූර්ණ සංඛ්‍යාවක් පරිවර්තනය කිරීමේ ප්‍රවේශය

දී ඇති ආදානය පූර්ණ සංඛ්‍යා දෙකකට බෙදීමට ගැටළුව අපෙන් ඉල්ලා සිටියේය. සපුරාලිය යුතු කොන්දේසිය ඉහත විස්තරයේ දැනටමත් සඳහන් කර ඇත. පළමු කොන්දේසිය නම් නිඛිලවල එකතුව දී ඇති පූර්ණ සංඛ්‍යාවට සමාන විය යුතුය. ප්‍රතිදානය ලෙස ආපසු ලබා දෙන පූර්ණ සංඛ්‍යා දෙකේ ඉලක්කම් 0 ක් අඩංගු නොවිය යුතුය. ගැටළුව විසඳීම සඳහා, අපි 1 සිට n දක්වා පරාසයක ඇති පළමු නිඛිලයට ඉහළින් ලූපයක් ධාවනය කරමු. දෙවන නිඛිලය පළමු සම්බන්ධතාවයෙන් අඩු කළ හැකිය. පූර්ණ සංඛ්‍යා දෙකම දෙවන කොන්දේසිය සපුරාලන්නේ දැයි අපි පරීක්ෂා කරමු.

දෙවන කොන්දේසිය පරීක්ෂා කිරීම සඳහා, අපි පූර්ණ සංඛ්‍යාවක් ආදානය ලෙස ගන්නා අභිරුචි ශ්‍රිතයක් නිර්මාණය කරමු. දී ඇති පූර්ණ සංඛ්‍යාවේ 0 අඩංගු ද නැද්ද යන්න මත පදනම්ව එය සත්‍ය හෝ අසත්‍ය වේ. පරීක්ෂා කිරීම සඳහා අපි කෙළවරේ සිට ඉලක්කම් එකින් එක ඉවත් කරමු.

කේතය

සී ++ කේතය, පූර්ණ සංඛ්‍යා රහිත ශුන්‍ය සංඛ්‍යා දෙකක ලීට්කෝඩ් විසඳුමේ එකතුවට පරිවර්තනය කිරීම

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

bool check(int n){
    while(n>0){
        if(n%10 == 0)
            return false;
        n/=10;
    }
    return true;
}

vector<int> getNoZeroIntegers(int n) {
    for(int i=1;i<n;i++){
        if(check(i) && check(n-i))
            return {i, n-i};
    }
    return {-1,-1};
}

int main(){
    int input = 1010;
    vector<int> output = getNoZeroIntegers(input);
    cout<<output[0]<<" "<<output[1];
}
11 999

පූර්ණ සංඛ්‍යා රහිත ශුන්‍ය සංඛ්‍යා දෙකක ලීට්කෝඩ් විසඳුමක එකතුවට ජාවා කේතය පරිවර්තනය කිරීම

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
  private static boolean check(int n){
        while(n>0){
            if(n%10 == 0)return false;
            n/=10;
        }
        return true;
    }
    
    public static int[] getNoZeroIntegers(int n) {
        for(int i=1;i<n;i++){
            if(check(i) && check(n-i))
                return new int[]{i, n-i};
        }
        return new int[]{-1,-1};
    }
    
  public static void main (String[] args) throws java.lang.Exception{
    int input = 1010;
      int[] output = getNoZeroIntegers(input);
      System.out.print(output[0]+" "+output[1]);
  }
}
11 999

සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

O (NlogN), මෙහි N යනු ආදානය ලෙස ලබා දී ඇති පූර්ණ සංඛ්‍යාවයි. ල log ු-සටහන පදනම් 10 ක් ඇත, මන්ද අපගේ පූර්ණ සංඛ්‍යාවේ 0 අඩංගුද නැද්ද යන්න පරීක්ෂා කරන අපගේ කාර්යය ලොග්එන් වේලාවෙන් ක්‍රියා කරයි.

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

ඕ (1), අපි කිසිදු තොරතුරක් ගබඩා නොකරමු. සමස්ත ඇල්ගොරිතම නියත විචල්‍ය සංඛ්‍යාවක් භාවිතා කරයි. මේ අනුව අවකාශයේ සංකීර්ණතාව නියත ය.