ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮದಿಂದ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಕೋಲೈಟ್ ಅಮೆಜಾನ್ ಫ್ಯಾನಟಿಕ್ಗಳು ಗೋಲ್ಡ್ಮನ್ ಸ್ಯಾಚ್ಸ್ ಮಾಹಿತಿ ಎಡ್ಜ್ Snapchat
ಅರೇ ಸ್ಟಾಕ್ ಸ್ಟ್ರಿಂಗ್

“ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮದಿಂದ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸಿ” ಎಂಬ ಸಮಸ್ಯೆಯು ನಿಮಗೆ ಕೆಲವು ಮಾದರಿಯನ್ನು ನೀಡಲಾಗಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ ಇದೆ ಮತ್ತು ಡಿ ಮಾತ್ರ. ಇದರ ಅರ್ಥ I ಹೆಚ್ಚಾಗುವುದನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆಯಾಗುವುದಕ್ಕಾಗಿ ನಮಗೆ ಒದಗಿಸಲಾಗಿದೆ D. ನೀಡಿರುವ ಮಾದರಿಯನ್ನು ತೃಪ್ತಿಪಡಿಸುವ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ಮುದ್ರಿಸಲು ಸಮಸ್ಯೆ ಹೇಳಿಕೆಯು ಕೇಳುತ್ತದೆ. ನಾವು 1-9 ರಿಂದ ಅಂಕೆಗಳನ್ನು ಬಳಸಬೇಕಾಗಿದೆ ಮತ್ತು ಯಾವುದೇ ಅಂಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಬಾರದು.

ಉದಾಹರಣೆ

DIID
21354

ವಿವರಣೆ

ಮೊದಲ ಅಂಕೆ 2 ಆಗಿದ್ದರೆ ಅದನ್ನು ಕಡಿಮೆ ಮಾಡಿದ ನಂತರ ಮುಂದಿನ ಅಂಕೆ 1 ಆಗಿರುತ್ತದೆ. ನಂತರ 2 ಅನ್ನು ಹೆಚ್ಚಿಸುವುದರಿಂದ 3 ಅನ್ನು ಕನಿಷ್ಟ ಅಂಕಿಯಾಗಿ 2 ಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿಸುತ್ತದೆ. ತದನಂತರ ನಾವು ಅದನ್ನು ಮತ್ತೆ ಹೆಚ್ಚಿಸಬೇಕು ಆದರೆ ಮತ್ತೆ ಹೆಚ್ಚಾದ ನಂತರ ನಾವು ಅದನ್ನು ಕಡಿಮೆ ಮಾಡಬೇಕು . ಅಂಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲದ ಕಾರಣ. ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು 2 ರಿಂದ ಹೆಚ್ಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಅದನ್ನು 1 ರಷ್ಟು ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ.

ಆದ್ದರಿಂದ output ಟ್ಪುಟ್ 2 1 3 5 4 ಆಗುತ್ತದೆ

ಮತ್ತೆ ನಾವು ಪ್ರಸ್ತುತ ಅಂಕಿಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತೇವೆ. ಆದರೆ ಅದನ್ನು ಮಾಡುವುದರಿಂದ ನಮಗೆ 4 ಸಿಗುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆಯಾದ ನಂತರ ನಾವು 1, 2, ಅಥವಾ 3 ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಮತ್ತು ಈ ಎಲ್ಲಾ ಅಂಕೆಗಳನ್ನು ಈಗಾಗಲೇ ಬಳಸಲಾಗುತ್ತಿತ್ತು. ಆದ್ದರಿಂದ ನಾವು ಪ್ರಸ್ತುತ ಅಂಕಿಯನ್ನು 5 ಕ್ಕೆ ಹೆಚ್ಚಿಸಬೇಕಾಗಿದೆ. ಮತ್ತು ನಾವು ಉತ್ತರವನ್ನು ಹೇಗೆ ತಲುಪುತ್ತೇವೆ.

ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮದಿಂದ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸುವ ಅಲ್ಗಾರಿದಮ್

  1. ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮ ಉದ್ದವು 9 ಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆಯೇ ಅಥವಾ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ನಿಜವಾಗಿದ್ದರೆ -1 ಹಿಂತಿರುಗಿ.
  2. N + 1 ಗಾತ್ರದ ಚಾರ್ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿ ಮತ್ತು ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು 1 ಕ್ಕೆ ಹೊಂದಿಸಿ.
  3. ರಚನೆಯನ್ನು 0 ರಿಂದ n ಗೆ (ಪ್ರಾರಂಭಿಸಿ) ಹಾದುಹೋಗಲು ಪ್ರಾರಂಭಿಸಿ.
    1. ಪರಿಶೀಲಿಸಿ i ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ n ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಸ್ತುತ ಅಕ್ಷರವು “ನಾನು” ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ, ಆಗ ನಿಜವಾಗಿದ್ದರೆ
      1. ಹಿಂದಿನ ಮೌಲ್ಯದಿಂದ -1 ಕ್ಕೆ ವ್ಯೂಹವನ್ನು ಹಾದುಹೋಗಿರಿ.
        1. ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ಮಾಡುವ ಮೂಲಕ array ಟ್‌ಪುಟ್ ರಚನೆಯ ಮೌಲ್ಯಗಳನ್ನು ನವೀಕರಿಸಿ.
          1. ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸಿ ಮತ್ತು ಅದನ್ನು output ಟ್‌ಪುಟ್ ಅರೇಗೆ ಸಂಗ್ರಹಿಸಿ.
          2. ಪರಿಶೀಲಿಸಿ j ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕವು 0 ಗಿಂತ ಹೆಚ್ಚಾಗಿದೆ, ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಸ್ತುತ ಅಕ್ಷರವು “ನಾನು”, ನಂತರ, ವಿರಾಮ.
  4. ರಿಟರ್ನ್ ಫಲಿತಾಂಶ.

ವಿವರಣೆ

ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ನಾನು ಮತ್ತು ಡಿ ಮಾತ್ರ ನೀಡಿದರೆ, ಕೊಟ್ಟಿರುವ ರೂಪದಲ್ಲಿ ರಚಿಸಬಹುದಾದ ಮಾದರಿಯನ್ನು ಮುದ್ರಿಸಲು ನಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್. ಇಲ್ಲಿ I ಹೆಚ್ಚಿಸುವುದನ್ನು ಸೂಚಿಸುತ್ತದೆ, ನಾವು ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮವನ್ನು ಸಮರ್ಥಿಸಬಲ್ಲ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ಮಾಡಬೇಕಾಗಿದೆ ಅಥವಾ ರೂಪಿಸಬೇಕು. ನಾವು ಹೇಳಿದರೆ ose ಹಿಸಿಕೊಳ್ಳಿ DIಅಲ್ಲಿ D ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಅಂದರೆ 2 ಅನ್ನು 21 ಅನ್ನು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯಾಗಿ ರೂಪಿಸುತ್ತದೆ. ಅಂಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುವುದಿಲ್ಲ, ಸಂಖ್ಯೆಯು 1-9 ರಿಂದ ಅಂಕೆಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿರುತ್ತದೆ. ಅದರ ನಂತರ, “ನಾನು” ಇದೆ, ನಾವು ಕನಿಷ್ಟ ಹೆಚ್ಚುತ್ತಿರುವ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸಬೇಕು. 21 ಈಗಾಗಲೇ ಇರುವುದರಿಂದ. ಹೆಚ್ಚುತ್ತಿರುವ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸುವ ಗುರಿ ಹೊಂದಿದ್ದೇವೆ. ಆದ್ದರಿಂದ 1 ಅನ್ನು 3 ರಿಂದ ಅನುಸರಿಸಲಾಗುತ್ತದೆ, ಏಕೆಂದರೆ 2 ಈಗಾಗಲೇ ಬಳಕೆಯಲ್ಲಿದೆ, ಮತ್ತು ಅದರ ನಂತರ 3 ಸೇರಬಹುದಾದ ಏಕೈಕ ಸಂಖ್ಯೆ.

ಈ ಎಲ್ಲಾ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಆಲೋಚನೆಗಳೊಂದಿಗೆ, ಕೊಟ್ಟಿರುವ ಷರತ್ತುಗಳನ್ನು ಅನುಸರಿಸುವ ಮತ್ತು ಪೂರೈಸುವ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ಮುದ್ರಿಸಲು ನಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ನಾವು output ಟ್ಪುಟ್ ಅರೇ ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ನಾವೆಲ್ಲರೂ ನಮ್ಮ output ಟ್ಪುಟ್ ಅನ್ನು ಆ ಅಕ್ಷರ ಶ್ರೇಣಿಗೆ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ಡೇಟಾ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಪರಿಶೀಲನೆಗಾಗಿ ನಾವು ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಮಾಡಿದ್ದೇವೆ. ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವು 9 ಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ ಅಥವಾ ಸಮನಾಗಿರುವುದನ್ನು ನಾವು ಕಂಡುಕೊಂಡರೆ, ನಂತರ ನಾವು -1 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ ಏಕೆಂದರೆ 1-9 ಅಂಕೆಗಳನ್ನು ಬಳಸಲು ನಾವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಆದೇಶಿಸಿದ್ದೇವೆ ಮತ್ತು ಯಾವುದೇ ಅಂಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುವುದಿಲ್ಲ.

ನಾವು ಸ್ವೀಕರಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ಹಾದುಹೋಗಿರಿ. ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕವು ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದಕ್ಕೆ ಸಮನಾಗಿದ್ದರೆ ಅಥವಾ ಪ್ರಸ್ತುತ ಅಕ್ಷರವು “I” ಗೆ ಸಮನಾಗಿದ್ದರೆ. ನಂತರ ಮಾತ್ರ ನಾವು ಮುಂದೆ ಹೋಗುತ್ತೇವೆ. ಅದರ ನಂತರ ಪ್ರಸ್ತುತ ಮೌಲ್ಯ (i) ಗೆ ಹಿಂದಿನ ಮೌಲ್ಯದಿಂದ -1 ಅನ್ನು ತಲುಪುವವರೆಗೆ ಪ್ರಾರಂಭಿಸಿ. ಈ ಲೂಪ್ ಒಳಗೆ ನಾವು ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಸೂಚ್ಯಂಕ j + 1 ನಲ್ಲಿ array ಟ್‌ಪುಟ್ ಅರೇನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ನಂತರ ಮೌಲ್ಯವಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ j ಗಿಂತ ದೊಡ್ಡದಾಗಿದೆ ಅಥವಾ ಸಮಾನವಾಗಿರುತ್ತದೆ 0 ಮತ್ತು ಪ್ರಸ್ತುತ ಅಕ್ಷರ “ನಾನು” ಆಗಿದ್ದರೆ. ನಿಜವಾಗಿದ್ದರೆ, ನಂತರ ಲೂಪ್ ಅನ್ನು ಮುರಿಯಿರಿ ಮತ್ತು ಹೆಚ್ಚಿನ ಅಕ್ಷರಗಳಿಗಾಗಿ ಮುಂದುವರಿಯಿರಿ.

ಕೋಡ್

ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮದಿಂದ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸಲು ಸಿ ++ ಕೋಡ್

#include<iostream>

using namespace std;

string getMinimumNumberSeq(string str)
{
    int n = str.length();

    if (n >= 9)
        return "-1";

    string output(n+1, ' ');

    int count = 1;

    for (int i = 0; i <= n; i++)
    {
        if (i == n || str[i] == 'I')
        {
            for (int j = i - 1 ; j >= -1 ; j--)
            {
                output[j + 1] = '0' + count++;
                if(j >= 0 && str[j] == 'I')
                    break;
            }
        }
    }
    return output;
}
int main()
{
    string inputs[] = { "DIID", "ID", "II", "DI", "DDII", "IDID", "IDIDID"};

    for (string input : inputs)
    {
        cout << getMinimumNumberSeq(input) << "\n";
    }
    return 0;
}
21354
132
123
213
32145
13254
1325476

ನಿರ್ದಿಷ್ಟ ಅನುಕ್ರಮದಿಂದ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ರೂಪಿಸಲು ಜಾವಾ ಕೋಡ್

class minimumNumberID
{
    static String getMinimumNumberSeq(String str)
    {
        int n = str.length();

        if (n >= 9)
            return "-1";

        char output[] = new char[n + 1];

        int count = 1;

        for (int i = 0; i <= n; i++)
        {
            if (i == n || str.charAt(i) == 'I')
            {
                for (int j = i - 1; j >= -1; j--)
                {
                    output[j + 1] = (char) ((int) '0' + count++);
                    if (j >= 0 && str.charAt(j) == 'I')
                        break;
                }
            }
        }
        return new String(output);
    }
    public static void main(String[] args)
    {
        String inputs[] = { "DIID", "ID", "II", "DI", "DDII", "IDID", "IDIDID" };

        for(String input : inputs)
        {
            System.out.println(getMinimumNumberSeq(input));
        }
    }
}
21354
132
123
213
32145
13254
1325476

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ಪ್ರಶ್ನೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವಾಗಿದೆ. ನಾವು ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಒಳಗೆ ಪ್ರವೇಶಿಸುತ್ತೇವೆಯೇ ಎಂದು ಮೊದಲು ಪರಿಶೀಲಿಸಿ, ನಾವು ಅಂತ್ಯವನ್ನು ತಲುಪಿದ್ದರೆ ಅಥವಾ ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ I ಆಗಿದ್ದರೆ ಮಾತ್ರ. ಮತ್ತು ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಹಿಂದುಳಿದ ದಿಕ್ಕಿನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ನಾನು ಅಡ್ಡಲಾಗಿ ಬಂದರೆ ನಾವು ಲೂಪ್ನಿಂದ ಹೊರಬರುತ್ತೇವೆ. ಆದ್ದರಿಂದ ನಾವು ಹೇಳಬಹುದು ನಾನು I ಅನ್ನು ಎದುರಿಸಿದಾಗ ನಾವು ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಡಿ ಸಂಗ್ರಹವಾಗಿರುವ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ಸೂಚ್ಯಂಕವು ನಾನು ಅಥವಾ ಡಿ ಅನ್ನು ಹೊಂದಿರಬಹುದು. ನಾವು ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಮೇಲೆ ಒಂದನ್ನು ಮಾತ್ರ ಹಾದುಹೋಗುತ್ತೇವೆ. ಹೀಗಾಗಿ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ರೇಖೀಯವಾಗಿರುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್), ಏಕೆಂದರೆ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು character ಟ್‌ಪುಟ್ ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಸಮಸ್ಯೆಯ ಸ್ಥಳ ಸಂಕೀರ್ಣತೆಯು ಸಹ ರೇಖೀಯವಾಗಿದೆ.