දහසක් බෙදුම්කරු ලීට්කෝඩ් විසඳුම


දුෂ්කරතා මට්ටම පහසු
String

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

මෙම ගැටළුව තුළ අපට negative ණාත්මක නොවන පූර්ණ සංඛ්‍යාවක් ලබා දී ඇත. අපට නිඛිලය එවැනි ආකෘතියකින් පරිවර්තනය කළ යුතු අතර, එහි දහස් ගණනක් වෙන් කරන තිත් කිහිපයක් ඇත, එනම් සෑම ස්ථාන 3 කටම දකුණේ සිට තිත් ඇත.

උදාහරණයක්

#1

n = 987
"987"

#2

n = 123456789
"123.456.789"

පැහැදිලි කිරීම:

අංකය 123456789. දකුණේ තිත දකුණේ සිට ස්ථාන 3 ක් වනු ඇත. ඉතින්, දකුණේ සිට බැලූ විට, අපි 9,8 සහ 7 අතහැර 6 සහ 7 අතර තිතක් තබමු. ඉන්පසු 6,5 සහ 4 පිටුපසින් ගිය පසු, අපි 3 ත් 4 ත් අතර තිතක් තබමු.
දැන් 3,2 සහ 1 ක් ඉතිරි කර, අපි තිතක් තබන්නේ වම් පසින් වැඩි සංඛ්‍යාවක් ඇත්නම් පමණි. ප්‍රශ්නයට අනුව අංක දෙකක් අතර විය යුතුය.
මේ අනුව අපි කිසිදු තිතක් තබන්නේ නැත.

ප්රවේශය

පළමුවෙන්ම, අපි අංකය නූල් බවට පරිවර්තනය කරමු (str කරමු). එවිට අපි නූල් දකුණේ සිට ගමන් කරමු. අපි මේ සඳහා for loop එකක් භාවිතා කරමු. සෑම පුඩුවක් තුළම අපි එහි ඉලක්කම් තුන ඇතුළත් කර තිතක් අනුගමනය කරමු.
නමුත් එක් එක් ඉලක්කම් ඇතුළත් කිරීමෙන් පසුව, අපි str හි වම් සීමාවෙන් පිටතට පැමිණ ඇත්දැයි පරීක්ෂා කරන්නෙමු. ඔව් නම්, අපි ලූපය බිඳ දමමු. එසේ නොමැති නම්, අපි දිගටම ඉලක්කම් 3 ඇතුළු 1 තිතක් ඇතුල් කරමු.

තිතක් ඇතුළු කිරීම සඳහා 3 වන පරීක්ෂාව තීරණාත්මක එකක් බව සලකන්න, එය 123 හෝ 123.456 හෝ 123.456.789 වැනි අවස්ථා වලදී භාවිතා කරනු ඇති අතර එහිදී අපට වම් කෙළවරට පෙර තිතක් ඇතුළු කිරීමට අවශ්‍ය නොවේ.
අප අක්‍ෂර දකුණේ සිට වමට ඇතුළු කරන නිසා අවසාන පිළිතුර ලබා ගැනීම සඳහා අප විසින් සාදන ලද නූල ආපසු හැරවිය යුතුය. මේ අනුව, ආපසු හැරවීමෙන් පසු පේළියකි, එය ආපසු දෙන්න.

දහසක් බෙදුම්කරු ලීට්කෝඩ් විසඳුම

ක්රියාත්මක කිරීම

සී ++ වැඩසටහන දහසක් බෙදුම්කරු ලීට්කෝඩ් විසඳුම සඳහා

#include <bits/stdc++.h> 
using namespace std;
string thousandSeparator(int n) {
    string str=to_string(n);
    stringstream ss;
    for(int i=str.length()-1;i>=0;){
        ss<<str[i];//inserting 1st digit
        i--;
        if(i==-1)break;//checking if we are out of left bound
        ss<<str[i];//inserting 2nd digit
        i--;
        if(i==-1)break;//checking if we are out of left bound
        ss<<str[i];//inserting 3rd digit
        i--;
        if(i==-1)break;//checking if we are out of left bound
        ss<<".";//after 3 digits insertion, finally inserting a dot "."
    }
    str= ss.str();
    reverse(str.begin(),str.end());//reversing the final string
    return str;
}

int main()
{
    cout << thousandSeparator(123456789);
}
123.456.789

දහසක් බෙදුම්කරු ලීට්කෝඩ් විසඳුම සඳහා ජාවා වැඩසටහන

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

class Solution
{  
    public static  String thousandSeparator(int n) 
    {
        String str=n+"";
        StringBuilder sb=new StringBuilder();
        for(int i=str.length()-1;i>=0;){
            sb.append(str.charAt(i));//inserting 1st digit
            i--;
            if(i==-1)break;//checking if we are out of left bound
            sb.append(str.charAt(i));//inserting 2nd digit
            i--;
            if(i==-1)break;//checking if we are out of left bound
            sb.append(str.charAt(i));//inserting 3rd digit
            i--;
            if(i==-1)break;//checking if we are out of left bound
            sb.append(".");//after 3 digits insertion, finally inserting a dot "."
        }
        return sb.reverse().toString();//reverse and return the final string
    }
    
    public static void main(String args[])
    {
        System.out.println(thousandSeparator(123456789));
    }
}
123.456.789

දහසක් බෙදුම්කරු ලීට්කෝඩ් විසඳුම සඳහා සංකීර්ණතා විශ්ලේෂණය

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

ඕ (ලෙන්): අපි දී ඇති සංඛ්‍යාව දකුණු ඉලක්කම් සිට වමට ගමන් කරන්නෙමු. මේ අනුව සංකීර්ණ කාලය O (len) වේ, එහිදී len යනු දී ඇති සංඛ්‍යාවේ ඉලක්කම් ගණන වේ.

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

ඕ (ලෙන්): අපි ජාවා හි ස්ට්‍රිංබිල්ඩරයක් සහ සී ++ හි ස්ට්‍රිංස්ට්‍රීම් භාවිතා කර ඇති අතර මේ නිසා අමතර ඉඩක් භාවිතා කිරීමෙන් අවකාශයේ සංකීර්ණතාව ඕ (ලෙන්) බවට පත් වේ.