റോമൻ ലീറ്റ്കോഡ് പരിഹാരത്തിലേക്ക് സംയോജിപ്പിക്കുക


വൈഷമ്യ നില മീഡിയം
പതിവായി ചോദിക്കുന്നു അഡോബി ആമസോൺ ആപ്പിൾ കറുത്ത പാറ ബ്ലൂംബർഗ് Evernote എന്നിവ ഫേസ്ബുക്ക് ഗൂഗിൾ ലിങ്ക്ഡ് മൈക്രോസോഫ്റ്റ് ഒറാക്കിൾ ട്വിറ്റർ യാഹൂ
മഠം സ്ട്രിംഗ്

ഈ പ്രശ്‌നത്തിൽ‌, ഞങ്ങൾക്ക് ഒരു സംഖ്യ നൽകിയിട്ടുണ്ട്, മാത്രമല്ല റോമൻ‌ അക്കങ്ങളായി പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്. അതിനാൽ ഈ പ്രശ്നത്തെ പൊതുവെ “ഇന്റീരിയർ ടു റോമൻ” എന്നും സാധാരണയായി ഇത് റോമൻ ലീറ്റ്കോഡ് സൊല്യൂഷൻ എന്നും വിളിക്കുന്നു. റോമൻ അക്കങ്ങളെക്കുറിച്ച് ആർക്കെങ്കിലും അറിയില്ലെങ്കിൽ. പഴയ കാലങ്ങളിൽ, സമീപകാലത്ത് ഞങ്ങൾ ഉപയോഗിക്കുന്നതുപോലെ ആളുകൾ പൂർണ്ണസംഖ്യകൾ ഉപയോഗിച്ചിരുന്നില്ല.

റോമൻ അക്കങ്ങൾ സാധാരണയായി ഇടത്തുനിന്ന് വലത്തോട്ട് ക്രമത്തിൽ കുറയുന്നു, പക്ഷേ ഇതിന് ചില അപവാദങ്ങളുണ്ട്. അടുത്ത സംഖ്യയേക്കാൾ ചെറുതായ ചില സംഖ്യകൾ പോസിറ്റീവ് സംഖ്യയിൽ നിന്ന് നിലവിലെ സംഖ്യ കുറയ്ക്കുന്നു. ഒരേ സംഖ്യയെ 3 തവണയിൽ കൂടുതൽ ആവർത്തിക്കരുത് എന്നതാണ് പൊതുവായ പെരുമാറ്റം. പൂർണ്ണസംഖ്യ മുതൽ റോമൻ സംഖ്യാ പരിവർത്തനം വരെ ചുവടെയുള്ള ചിത്രം പരിശോധിക്കണം.

റോമൻ ലീറ്റ്കോഡ് പരിഹാരത്തിലേക്ക് സംയോജിപ്പിക്കുക

3
III

വിശദീകരണം: ഞാൻ 1 ന് തുല്യമായതിനാൽ, തുക = 3 ലഭിക്കാൻ ഞങ്ങൾ ഇത് മൂന്ന് തവണ ആവർത്തിക്കുന്നു.

4
IV

വിശദീകരണം: ഞങ്ങൾക്ക് 4 തവണ ആവർത്തിക്കാൻ കഴിയില്ല, കാരണം എനിക്ക് 3 തവണയിൽ കൂടുതൽ ആവർത്തിക്കാൻ കഴിയില്ല. അതിനാൽ നമ്മൾ V- യ്ക്ക് മുമ്പായി ഒരു പ്ലെയിൻ ചെയ്യുന്നു. ഞാൻ V- നേക്കാൾ കുറവായതിനാൽ 1 എന്നത് 5-ന് തുല്യമായ ആകെ തുകയിൽ നിന്ന് കുറയ്ക്കുന്നു. അങ്ങനെ ആകെ തുക 4 ന് തുല്യമാക്കുന്നു.

റോമൻ ലീറ്റ്കോഡ് പരിഹാരത്തിലേക്കുള്ള സംയോജനത്തിനുള്ള സമീപനം

“ഇന്റീരിയർ ടു റോമൻ” എന്ന പ്രശ്നം അത്യാഗ്രഹത്തോടെ പരിഹരിക്കാനാകും, അവിടെ ആദ്യം നാം സംഖ്യയെ സാധ്യമായ ഏറ്റവും ഉയർന്ന സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുന്നു. പ്രശ്‌നത്തോടുള്ള ക്രൂരമായ ബലപ്രയോഗം സാധ്യമല്ല, കാരണം ഇത് പ്രായോഗികമോ പൊതുവായി ബാധകമോ അല്ല. ഈ രീതിയിൽ ഞങ്ങൾ റോമൻ സംഖ്യയിലെ ചെറിയ വിഭാഗങ്ങളിലേക്ക് നീങ്ങുന്നു. 4 പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഈ സമീപനം പരാജയപ്പെടും. ഈ സമീപനം 4 തവണ I അച്ചടിക്കും. അതിനാൽ, ഇതിനെ മറികടക്കാൻ ഞങ്ങൾ ഒരു വഴി കണ്ടെത്തേണ്ടതുണ്ട്.

ശരി, സൂക്ഷ്മമായി പരിശോധിച്ചാൽ ഈ അപവാദത്തിലേക്ക് കടക്കാൻ കഴിയുമ്പോൾ കണക്കാക്കാവുന്ന ചില വഴികൾ മാത്രമേയുള്ളൂ. ചില സംഖ്യകളെ 3 തവണയിൽ കൂടുതൽ ആവർത്തിക്കുമ്പോൾ മാത്രമാണ് ഈ അപവാദം. അതിനാൽ പൂർണ്ണസംഖ്യകൾ എഴുതാനുള്ള വഴികൾ കണ്ടെത്താൻ ശ്രമിക്കുക. 4, 9, 40, 90, 400, 900 എന്നിവ യഥാക്രമം IV, IX, XL, XC, CD, CM ആയി പരിവർത്തനം ചെയ്യാൻ കഴിയുമെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു.

ഒഴിവാക്കലുകളുമായി ഇടപെടുക

അതിനാൽ, തന്നിരിക്കുന്ന സംഖ്യയെ ലഭ്യമായ യഥാർത്ഥ സിംഗിൾ പ്രതീകമായ റോമൻ അക്കങ്ങളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനെക്കുറിച്ച് ഞങ്ങൾ ഇപ്പോൾ ചിന്തിച്ചിരുന്നു. എന്നാൽ ഒഴിവാക്കൽ ഒഴിവാക്കാൻ, ഞങ്ങൾ അവയെ പ്രത്യേകം കൈകാര്യം ചെയ്യുന്നു. അങ്ങനെ, ഞങ്ങൾ രണ്ട് സൃഷ്ടിക്കുന്നു ശ്രേണികൾ ഓരോ റോമൻ അക്കങ്ങൾക്കും അനുയോജ്യമായ സംയോജിത മൂല്യം സംഭരിക്കുന്ന ഒന്ന്. മറ്റ് അറേ റോമൻ അക്കങ്ങൾ സംഭരിക്കുന്നു. ഈ രണ്ട് അറേകളും പൂർണ്ണസംഖ്യകളും റോമൻ നമ്പറുകളും ഒരേ അനുബന്ധ സൂചികകളിൽ സംഭരിക്കുന്നു.

ഇപ്പോൾ, അവശേഷിക്കുന്നത് അത്യാഗ്രഹത്തോടെയുള്ള പരിവർത്തനം മാത്രമാണ്. ഏറ്റവും വലിയ റോമൻ സംഖ്യയിൽ ആരംഭിക്കുക, നിലവിലെ റോമൻ സംഖ്യയെക്കാൾ വലുതാണെങ്കിൽ. റോമൻ സംഖ്യയെ ഒരു ഉത്തരമായി കൂട്ടിച്ചേർക്കുക സ്ട്രിംഗ് തന്നിരിക്കുന്ന സംഖ്യയിൽ നിന്ന് അവിഭാജ്യ മൂല്യം കുറയ്ക്കുക. തന്നിരിക്കുന്ന സംഖ്യ നിലവിലെ സംഖ്യയേക്കാൾ വലുതായിരിക്കുന്നതുവരെ നിലവിലെ നമ്പർ കുറയ്ക്കുക. നിലവിലെ സംഖ്യ നിലവിലെ സംഖ്യ മൂല്യത്തേക്കാൾ ചെറുതായിരിക്കുമ്പോൾ നിങ്ങൾ ഒരു പോയിന്റിൽ എത്തിക്കഴിഞ്ഞാൽ. അടുത്ത ചെറിയ റോമൻ സംഖ്യകൾക്കായി പരിശോധിക്കുക. എല്ലാ റോമൻ അക്കങ്ങളും പൂർത്തിയാക്കിക്കഴിഞ്ഞാൽ, ഞങ്ങൾ ഉത്തരം നൽകുന്നു.

റോമൻ ലീറ്റ്കോഡ് പരിഹാരത്തിലേക്കുള്ള സംയോജനത്തിനുള്ള കോഡ്

ഇന്റർ‌ജർ‌ ടു റോമൻ‌ ലീറ്റ്‌കോഡ് സൊല്യൂഷനുള്ള സി ++ കോഡ്

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

string intToRoman(int num) {
    vector<string> romans({"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"});
    vector<int> value({1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000});
    int seqSize = romans.size();
    int idx = seqSize - 1;
    string ans = "";
    while(num>0){
        while(value[idx]<=num){
            ans += romans[idx];
            num -= value[idx];
        }
        idx--;
    }
    return ans;
}

int main(){
    cout<<intToRoman(4);
}
IV

റോമൻ ലീറ്റ്‌കോഡ് പരിഹാരത്തിനുള്ള സംഖ്യയ്‌ക്കായുള്ള ജാവ കോഡ്

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

class Main {
    public static String intToRoman(int num) {
        String romans[] = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
        int value[] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
        int seqSize = romans.length;
        int idx = seqSize - 1;
        String ans = "";
        while(num>0){
            while(value[idx]<=num){
                ans += romans[idx];
                num -= value[idx];
            }
            idx--;
        }
        return ans;
    }
    public static void main(String[] args){
    	System.out.println(intToRoman(4));
    }
}

 

IV

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (1), കാരണം ഫലം കണ്ടെത്താൻ ഞങ്ങൾ നിരന്തരമായ ഘട്ടങ്ങൾ ഉപയോഗിക്കുന്നു.

ബഹിരാകാശ സങ്കീർണ്ണത

O (1), സ്ഥിരമായ വേരിയബിളുകളുടെ എണ്ണം മാത്രമേ ഞങ്ങൾ സംഭരിച്ചിട്ടുള്ളൂ, ഞങ്ങൾ ഉപയോഗിച്ച അറേകൾക്കും സ്ഥിരമായ വലുപ്പമുണ്ട്.