רוימישע צו ינטעגער לעעטקאָדע סאַלושאַן  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַדאָובי אַמאַזאָן עפּל בלומבערג facebook גאָלדמאַן סאַקס גוגל לינקעדין מייקראָסאָפֿט אָראַקל Qualtrics ראָבלאָקס ובער יאַהאָאָ
אַלגערידאַמז קאָדירונג אינטערוויו interviewprep LeetCode LeetCodeSolutions מאַט שטריקל

אין דעם פּראָבלעם "רוימישע צו ינטעגער", מיר זענען געגעבן אַ שטריקל רעפּריזענינג אַ positive ינטאַדזשער אין זיין רוימער ציפער פאָרעם. רוימער נומעראַלס זענען רעפּריזענטיד דורך 7 אותיות וואָס קענען זיין קאָנווערטעד צו ינטאַדזשערז מיט די פאלגענדע טיש:

רוימישע צו ינטעגער לעעטקאָדע סאַלושאַן

טאָן: די גאַנץ ווערט פון די געגעבן רוימער נומער וועט נישט יקסיד אָדער גלייַך די ווערט 4000.

בייַשפּיל  

IX
9
CXXIX
129

דערקלערונג # 1

IX איז 9 אין גאַנץ נומערן

דערקלערונג # 2

CXXIX = C + XX + IX = 100 + 20 + 9 = 129

צוגאַנג (לינקס צו רעכט פאָרן)  

מיר קענען פאָרן לינקס צו רעכט אין די מענגע און האַלטן די קאָראַספּאַנדינג ווערט פֿאַר יעדער כאַראַקטער אין עס. אָבער, די מאָדנע אַספּעקט פון רוימער נומעראַלס איז אויב אַ כאַראַקטער פון ווייניקער גאַנץ ווערט אַקערז איידער אַ הויך ווערט, דער רעזולטאַט איז נישט זייער באַזונדער סומע.

פֿאַר בייַשפּיל, IX אין Roman זאָל זיין 1 + 10 = 11 אויב מיר נאָך לייגן אותיות. אָבער, IX = 9, ווי אַז אַקערז איידער X איז ווייניקער אין ינטאַגראַל ווערט. דער רעזולטאַט איז באהאנדלט ווי I אראפגענומען פון X. דעריבער, IX = 9.

דעריבער, מיר קענען נישט לייגן די ינטאַדזשער ווערט פון יעדער כאַראַקטער אין די שטריקל פשוט. פֿאַר דעם אויבן דערמאנטן פאַל, מיר דאַרפֿן צו קאָנטראָלירן די כאַראַקטער ווייַטער צו אים. אין דעם וועג, מיר קענען בייַטן די געגעבן רוימער נומעראַל שטריקל אין די פארלאנגט ינטאַדזשער.

זע אויך
דרייען רשימה לעעטקאָדע סאַלושאַן

אַלגאָריטהם

  1. שאַפֿן אַ פֿונקציע געטינטעגער () צו ווייַזן די ווערט פון אַ איין רוימישע כאַראַקטער וואָס איז דורכגעגאנגען צו אים ניצן יבערבייַט פאלן
  2. Initialize טאַכלעס צו קראָם פארלאנגט ינטאַדזשער
  3. ווידער, יניטיאַליזירן קראַנט און ווייַטער צו קראָם די ווערט פון קראַנט און ווייַטער ינטאַדזשער וואַלועס פון ריספּעקטיוו אותיות אין די שטריקל פֿאַר יעדער יטעראַטיאָן
  4. יטעראַטע פֿאַר איך = 0 ביז i <N  (N = גרייס פון דעם מענגע)
    • If i איז די לעצטע אינדעקס פון די מענגע, מיר האָבן קיין ווייַטער כאַראַקטער, אַזוי לייגן ינטעגער ווערט פון שטריקל [i] און צוריקקומען טאַכלעס
    • צוריקקריגן די ינטאַדזשער ווערט פון קראַנט און ווייַטער אותיות ניצן געטינטעגער ()
    • If קראַנט <= ווייַטער
      • צוגעבן קראַנט צו די טאַכלעס
      • Increment i ביי 1, ד"ה i++
    • אַנדערש
      • צוגעבן ווייַטער - קראַנט צו די טאַכלעס
      • Increment i ביי 2, ד"ה i + = 2
  5. דרוק דעם רעזולטאַט

ימפּלעמענטאַטיאָן פון רוימער צו ינטעגער לעעטקאָדע סאַלושאַן

C ++ פּראָגראַם

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

int getInteger(char c)
{
    switch(c)
    {
        case 'I' : return 1;
        case 'V' : return 5;
        case 'X' : return 10;
        case 'L' : return 50;
        case 'C' : return 100;
        case 'D' : return 500;
        case 'M' : return 1000;
        default : return -1;
    }
}

int romanToInt(string s)
{
    int n = s.size() , result = 0 , current , next , i = 0;
    while(i < n)
    {
        if(i == n - 1)
        {
            result += getInteger(s[i]);
            return result;
        }
        current = getInteger(s[i]) , next = getInteger(s[i + 1]);
        if(current >= next)
            result += current , i++;
        else
            result += next - current , i += 2;
    }
    return result;
}

int main()
{
    string s = "CXXIX";
    cout << romanToInt(s) << '\n';
    return 0;
}

Java פּראָגראַם

class roman_to_int
{
    public static void main(String args[])
    {
        String s = "CXXIX";
        System.out.println(romanToInt(s));
    }

    static int getInteger(char c)
    {
        switch(c)
        {
            case 'I' : return 1;
            case 'V' : return 5;
            case 'X' : return 10;
            case 'L' : return 50;
            case 'C' : return 100;
            case 'D' : return 500;
            case 'M' : return 1000;
            default : return -1;
        }
    }

    static int romanToInt(String s)
    {
        int n = s.length() , result = 0 , current , next , i = 0;
        while(i < n)
        {
            if(i == n - 1)
            {
                result += getInteger(s.charAt(i));
                return result;
            }
            current = getInteger(s.charAt(i));
            next = getInteger(s.charAt(i + 1));
            if(current >= next)
            {
                result += current;
                i++;
            }
            else
            {
                result += next - current;
                i += 2;
            }
        }
        return result;
    }
}
129

קאַמפּלעקסיטי אַנאַליסיס פון רוימער צו ינטעגער לעעטקאָדע סאַלושאַן

צייט קאַמפּלעקסיטי

דאָ, מיר פאָרן דורך די שטריקל אַמאָל. זינט מיר האָבן אַ גאַנץ נומער שיעור ווייניקער ווי 4000, די שטריקל גרייס איז שטענדיק אַ קעסיידערדיק ווערט. דעריבער, די צייט קאַמפּלעקסיטי איז אָ (1).

זע אויך
גראַפיק קלאָונינג

אָרט קאַמפּלעקסיטי

אָ (1), מיר נאָר נוצן קעסיידערדיק זיקאָרן פּלאַץ.

צוגאַנג (רעכט צו לינקס פאָרן)  

דער חילוק צווישן רעכט-צו-לינקס און לינקס-צו-רעכט ליגט אין זייער ימפּלאַמענטיישאַן. אין רעכט-צו-לינקס פאָרן, מיר קענען אָנהייבן פֿון די רגע לעצט אינדעקס פון די מענגע, סטאָרינג די ינטאַדזשער ווערט פון די לעצטע כאַראַקטער אין עטלעכע בייַטעוודיק. מיר האַלטן די ינטאַגראַל ווערט פון די לעצטע כאַראַקטער ביז דער רעזולטאַט פריער. איצט ווען מיר מאַך פֿון רעכטס צו לינקס, קאָנטראָלירן ביי יעדער שריט צי די גאַנץ ווערט פון דעם קראַנט כאַראַקטער איז ווייניקער ווי די לעצטע (פרייַערדיק / רעכט) עלעמענט וואָס מיר האָבן געזען. אויב עס איז ווייניקער ווי די לעצטע ווערט, מיר אַראָפּרעכענען דעם ווערט פון די רעזולטאַט. אַנדערש מיר לייגן עס צו אונדזער רעזולטאַט. די ימפּלאַמענטיישאַן איז טאָוטאַלי באזירט אויף די אויבן פאַקט אַז קלענערער-וואַליוד כאַראַקטער איידער אַ גרעסער-וואַליוד איינער מיטל אַז עס מוזן זיין סאַבטראַקטיד פון די יענער.

דער צוגאַנג איז כּמעט די זעלבע אין די נומער פון אַפּעריישאַנז ווי די פריערדיקע צוגאַנג, אָבער איז מער באַקוועם ווייַל מיר באַקומען באַפרייַען פון די לעצטע עלעמענט פֿאַר יעדער יטעראַטיאָן.

אַלגאָריטהם

  1. שאַפֿן אַ פֿונקציע געטינטעגער () ענלעך ווי אויבן
  2. קראָם די ינטאַדזשער ווערט פון די לעצטע כאַראַקטער פון די שטריקל אין פריער
  3. Initialize טאַכלעס גלייך צו פריער
  4. יטעראַטע פון i = N - 2 ביז איך> = 0:
    1. קראָם גאַנץ נומער פון קראַנט כאַראַקטער ווי קראַנט
    2. If קראַנט איז ווייניקער ווי פריער
      1. Subtract קראַנט פון טאַכלעס, אַז איז, טאַכלעס -= קראַנט
    3. אַנדערש
      1. צוגעבן קראַנט צו טאַכלעס, אַז איז, טאַכלעס += קראַנט
  5. דרוק דעם רעזולטאַט

ימפּלעמענטאַטיאָן פון רוימער צו ינטעגער לעעטקאָדע סאַלושאַן

C ++ פּראָגראַם

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

int getInteger(char c)
{
    switch(c)
    {
        case 'I' : return 1;
        case 'V' : return 5;
        case 'X' : return 10;
        case 'L' : return 50;
        case 'C' : return 100;
        case 'D' : return 500;
        case 'M' : return 1000;
        default : return -1;
    }
}

int romanToInt(string s)
{
    int n = s.size();
    int prev = getInteger(s[n - 1]) , result = prev , current;
    for(int i = n - 2 ; i >= 0 ; i--)
    {
        current = getInteger(s[i]);
        if(current < prev)
            result -= current;
        else
            result += current;
        prev = current;
    }
    return result;
}

int main()
{
    string s = "CXXIX";
    cout << romanToInt(s) << '\n';
    return 0;
}

Java פּראָגראַם

class roman_to_int
{
    public static void main(String args[])
    {
        String s = "CXXIX";
        System.out.println(romanToInt(s));
    }

    static int getInteger(char c)
    {
        switch(c)
        {
            case 'I' : return 1;
            case 'V' : return 5;
            case 'X' : return 10;
            case 'L' : return 50;
            case 'C' : return 100;
            case 'D' : return 500;
            case 'M' : return 1000;
            default : return -1;
        }
    }

    static int romanToInt(String s)
    {
        int n = s.length();
        int prev = getInteger(s.charAt(n - 1)) , result = prev , current;
        for(int i = n - 2 ; i >= 0 ; i--)
        {
            current = getInteger(s.charAt(i));
            if(current < prev)
                result -= current;
            else
                result += current;
            prev = current;
        }
        return result;
    }
}
129

קאַמפּלעקסיטי אַנאַליסיס פון רוימער צו ינטעגער לעעטקאָדע סאַלושאַן

צייט קאַמפּלעקסיטי

ווידער מיר פאָרן די שטריקל אַמאָל. ווי דיסקאַסט אויבן, די צייט קאַמפּלעקסיטי איז אָ (1).

זע אויך
גראף פּרימעס אין ראַנגעס

אָרט קאַמפּלעקסיטי

אָ (1), מיר נאָר נוצן קעסיידערדיק זיקאָרן פּלאַץ.