ಅನುಮತಿಸಲಾದ ನಕಲುಗಳೊಂದಿಗೆ ಅರೇ ಪರಸ್ಪರ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ


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

ನಿಮಗೆ ಒಂದು ನೀಡಲಾಗಿದೆ ಸರಣಿ ನಕಲಿ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಪೂರ್ಣಾಂಕಗಳ. ಸಮಸ್ಯೆಯ ಹೇಳಿಕೆಯು ಇದು ಒಂದು ಪೂರ್ಣಸಂಖ್ಯೆಯ ಗುಂಪೇ ಎಂದು ಕಂಡುಹಿಡಿಯಲು ಕೇಳುತ್ತದೆ, ಅದು “ಹೌದು” ಎಂದು ಮುದ್ರಿಸಿ, ಇಲ್ಲದಿದ್ದರೆ “ಇಲ್ಲ” ಎಂದು ಮುದ್ರಿಸಿ.

ಉದಾಹರಣೆ

ಮಾದರಿ ಇನ್ಪುಟ್:

[2, 3, 4, 1, 7, 9]

ಮಾದರಿ put ಟ್‌ಪುಟ್:

ಹೌದು

ವಿವರಣೆ:

ಇದು [2, 3, 4, 1] ಸಂಖ್ಯೆಯ ಪೂರ್ಣಸಂಖ್ಯೆಗಳ ಗುಂಪನ್ನು ಹೊಂದಿದೆ.

ಅನುಮತಿಸಲಾದ ನಕಲುಗಳೊಂದಿಗೆ ಅನುಕ್ರಮವು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಅಲ್ಗಾರಿದಮ್

1. Declare a Set.
2. Add all the elements of an array into the Set.
3. Set count to 1 and currentElement to arr[0]-1.
4. Open a loop, while Set contains the currentElement.
  1. Do count++ and currentElement--.
5. Set currentElement to arr[0]+1.
6. Open a loop, while Set contains the currentElement.
  1. Do count++ and currentElement++.
7. Check if the count is equal to the size of a set, if condition satisfies, then return true.
8. Else return false.

ವಿವರಣೆ

ಕೊಟ್ಟಿರುವ ರಚನೆಯು ಒಂದು ಗುಂಪನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಲು ನಮಗೆ ಪ್ರಶ್ನೆಯನ್ನು ನೀಡಲಾಗುತ್ತದೆ ಪರಸ್ಪರ ಪೂರ್ಣಾಂಕಗಳು. ಅದು ಇದ್ದರೆ ಹೌದು ಇಲ್ಲದಿದ್ದರೆ ಬೇರೆ ಮುದ್ರಿಸು. ನಾವು a ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ ಸೆಟ್ ಏಕೆಂದರೆ ಅದು ಎಲ್ಲಾ ನಕಲಿ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ನಮ್ಮ ಕೆಲಸವನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಕೆಲವು ನಕಲಿ ಅಂಶಗಳಾಗಿರುವ ಹಲವು ಅಂಶಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಸೆಟ್ ಭವಿಷ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಂತರ ಅದು ಎಲ್ಲಾ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ವಿಭಿನ್ನ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿರುತ್ತದೆ.

ನಾವು ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಹೋಗುತ್ತೇವೆ ಹೊಂದಿಸಿ ಮತ್ತು ಇದು ಈಗ ವಿಭಿನ್ನ ಅಂಶಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು 1 ಕ್ಕೆ ಹೊಂದಿಸಿ ಮತ್ತು ನಂತರದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ನಾವು ಅದನ್ನು ಹೆಚ್ಚಿಸುತ್ತಲೇ ಇರುತ್ತೇವೆ. ಇದು ಪೂರ್ಣಾಂಕಗಳ ಸಮೀಪವಿರುವ ಗುಂಪಿನ ಗಾತ್ರವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಯಾವುದೇ ಪೂರ್ಣಾಂಕಗಳಿಲ್ಲದಿದ್ದರೆ ಅದು ಸೆಟ್ಗಿಂತ ವಿಭಿನ್ನ ಗಾತ್ರವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅರ್ [0] -1 ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್‌ನ ಮೌಲ್ಯವಾಗಿರುತ್ತದೆ. ಇದು ಸೆಟ್ ಮೇಲೆ ಕಣ್ಣಿಡುತ್ತದೆ ಪೂರ್ಣಾಂಕಗಳು.

ಒಂದು ಲೂಪ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಸೆಟ್‌ನಲ್ಲಿ ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ ಇರುವವರೆಗೂ ಅದು ಮುಂದುವರಿಯುತ್ತದೆ, ಏಕೆಂದರೆ ಒಂದು ಲೂಪ್‌ನಲ್ಲಿ ನಾವು ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಲಿದ್ದೇವೆ (ಎಣಿಕೆ = ಎಣಿಕೆ + 1) ಮತ್ತು ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್‌ನ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಕಡಿಮೆಗೊಳಿಸುತ್ತೇವೆ (ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ = ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ - 1). ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್‌ನ ಮೌಲ್ಯವನ್ನು arr [0] +1 ಗೆ ಹೊಂದಿಸಿ ಮತ್ತು ಇನ್ನೊಂದು ಲೂಪ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಸೆಟ್‌ನಲ್ಲಿ ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ ಇರುವವರೆಗೂ ಇದು ಮುಂದುವರಿಯುತ್ತದೆ, ಆದರೆ ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಎರಡೂ ಮೌಲ್ಯಗಳನ್ನು 1 ಎಣಿಕೆ ++ ಮತ್ತು ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ ++ ಮೂಲಕ ಹೆಚ್ಚಿಸುತ್ತೇವೆ. ಕೊನೆಗೆ, ಎಣಿಕೆಯ ಮೌಲ್ಯವು ಸೆಟ್ನ ಗಾತ್ರಕ್ಕೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಅದು ನಿಜವೆಂದು ಕಂಡುಬಂದಲ್ಲಿ ನಿಜವೆಂದು ಹಿಂತಿರುಗಿ ಇಲ್ಲದಿದ್ದರೆ ಸುಳ್ಳನ್ನು ಹಿಂತಿರುಗಿ.

ನಾವು ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ:

ಉದಾಹರಣೆ

arr [] = {5, 2, 3, 6, 4, 4, 6, 6};

ರಚನೆಯನ್ನು ದಾಟಿದ ನಂತರ, ನಾವು ಈ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಸೆಟ್ನಲ್ಲಿ ಹೊಂದಿದ್ದೇವೆ.

ಹೊಂದಿಸಿ: {2,3,4,5,6}, ಏಕೆಂದರೆ ಇದು ನಕಲಿ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ

ಎಣಿಕೆ = 1, ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ = ಅರ್ [0] -1 = 4;

  • ಸೆಟ್ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ (4) ನಿಜ,

ಎಣಿಕೆ = ಎಣಿಕೆ + 1 => ಎಣಿಕೆ = 2, ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್– => ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ = 3

  • ಸೆಟ್ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ (3) ನಿಜ,

ಎಣಿಕೆ = ಎಣಿಕೆ + 1 => ಎಣಿಕೆ = 3, ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್– => ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ = 2

  • ಸೆಟ್ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ (2) ನಿಜ,

ಎಣಿಕೆ = ಎಣಿಕೆ + 1 => ಎಣಿಕೆ = 4, ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್– => ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ = 1

  • ಸೆಟ್ ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ (1) ಅನ್ನು ಹೊಂದಿದ್ದರೆ ಅದು ಸುಳ್ಳು, ಆದ್ದರಿಂದ ಅದು ಲೂಪ್ನಿಂದ ಹೊರಬರುತ್ತದೆ.

ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿಸಿ [0] = arr [0] +1 => currentElement = 6

  • ಸೆಟ್ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ (6) ನಿಜ,

ಎಣಿಕೆ = ಎಣಿಕೆ + 1 => ಎಣಿಕೆ = 5, ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ ++ => ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್ = 7

  • ಸೆಟ್ ಕರೆಂಟ್ ಎಲಿಮೆಂಟ್ (7) ಅನ್ನು ಹೊಂದಿದ್ದರೆ ಅದು ಲೂಪ್ನಿಂದ ಹೊರಬರುತ್ತದೆ

ಮತ್ತು ಎಣಿಕೆ ಸೆಟ್ನ ಗಾತ್ರಕ್ಕೆ ಸಮನಾಗಿದೆಯೇ ಮತ್ತು ಸ್ಥಿತಿಯು ತೃಪ್ತಿಪಡಿಸುತ್ತದೆಯೇ ಎಂದು ಅದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಆದ್ದರಿಂದ ಅದು ನಿಜವಾಗುವುದು ಮತ್ತು ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ ಹೌದು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

ಅನುಷ್ಠಾನ

ಅನುಮತಿಸಲಾದ ನಕಲುಗಳೊಂದಿಗೆ ಅನುಕ್ರಮವು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಸಿ ++ ಕೋಡ್

#include<iostream>
#include<unordered_set>
using namespace std;
bool areElementsContiguous(int arr[], int n)
{
    unordered_set<int> Set;
    for (int i = 0; i < n; i++)
        Set.insert(arr[i]);

    int count = 1;
    int currentElement = arr[0] - 1;
    while (Set.find(currentElement) != Set.end())
    {
        count++;
        currentElement--;
    }
    currentElement = arr[0] + 1;
    while (Set.find(currentElement) != Set.end())
    {
        count++;
        currentElement++;
    }
    return (count == (int)(Set.size()));
}
int main()
{
    int arr[] = { 5, 2, 3, 6, 4, 4, 6, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    if (areElementsContiguous(arr, n))
        cout << "Yes, it is set of contiguous integers.";
    else
        cout << "No, it is not a set of contiguous integers.";
    return 0;
}
Yes, it is set of contiguous integers.

ರಚನೆಯು ಅನುಮತಿಸಲಾದ ನಕಲುಗಳೊಂದಿಗೆ ಪರಸ್ಪರ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಜಾವಾ ಕೋಡ್

import java.util.HashSet;
class contiguousArray
{
    public static Boolean checkContiguousElements(int arr[], int n)
    {
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < n; i++)
        {
            set.add(arr[i]);
        }
        int count = 1;
        int currentElement = arr[0] - 1;
        while (set.contains(currentElement) == true)
        {
            count++;
            currentElement--;
        }
        currentElement = arr[0] + 1;
        while (set.contains(currentElement) == true)
        {
            count++;
            currentElement++;
        }
        return (count == (set.size()));
    }
    public static void main(String[] args)
    {
        int arr[] = { 10, 7, 8, 11, 9, 9, 10, 10 };
        int n = arr.length;
        if (checkContiguousElements(arr, n))
            System.out.println("Yes, it is set of contiguous integers.");
        else
            System.out.println("No, it is not a set of contiguous integers.");
    }
}
Yes, it is set of contiguous integers.

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

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

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

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.