ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳು ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ  


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಫೇಸ್ಬುಕ್ ಯಾಂಡೆಕ್ಸ್
ಅಲ್ಗಾರಿದಮ್ಗಳು ಅರೇ ಕೋಡಿಂಗ್ ಸಂದರ್ಶನ ಸಂದರ್ಶನ ಪೂರ್ವಭಾವಿ ಲೀಟ್‌ಕೋಡ್ LeetCodeSolutions

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ  

ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳ ಸಮಸ್ಯೆಯಲ್ಲಿ a ಅನನ್ಯ ವಿಂಗಡಿಸಲಾಗಿದೆ ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಯನ್ನು ನೀಡಲಾಗಿದೆ. ನಾವು ಮಾಡಬೇಕು ಚಿಕ್ಕದಾದ ವಿಂಗಡಿಸಲಾಗಿದೆ ಶ್ರೇಣಿಗಳ ಪಟ್ಟಿ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತದೆ ಸರಣಿ ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಅಂದರೆ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವು ನಿಖರವಾಗಿ ಒಂದು ಶ್ರೇಣಿಗಳಿಂದ ಆವರಿಸಲ್ಪಟ್ಟಿದೆ.

ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಶ್ರೇಣಿ [a, b] output ಟ್‌ಪುಟ್ ಆಗಿರಬೇಕು:

“ಎ-> ಬಿ” ಒಂದು ವೇಳೆ! = ಬಿ
ಒಂದು == ಬಿ ಆಗಿದ್ದರೆ “ಎ”

ಉದಾಹರಣೆ

nums = [0,1,2,4,5,7]
["0->2","4->5","7"]

ವಿವರಣೆ:

ವ್ಯಾಪ್ತಿಗಳು ಹೀಗಿವೆ:
“0-> 2” numbers 0, 1, 2 numbers ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
“4-> 5” numbers 4, 5 numbers ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
“7” numbers 7 numbers ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ

ಆದ್ದರಿಂದ ಇದು ಎಲ್ಲಾ ಸಂಖ್ಯೆಯ ಶ್ರೇಣಿಯನ್ನು ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಒಳಗೊಳ್ಳುತ್ತದೆ.

nums = [0,2,3,4,6,8,9]
["0","2->4","6","8->9"]

ವಿವರಣೆ:

ವ್ಯಾಪ್ತಿಗಳು ಹೀಗಿವೆ:
[0,0] -> “0”
[2,4] -> “2-> 4”
[6,6] -> “6”
[8,9] -> “8-> 9”

ಅಪ್ರೋಚ್  

ಮೇಲೆ ಹೇಳಿದಂತೆ ನಾವು ಶ್ರೇಣಿಗಳ ಚಿಕ್ಕ ಪಟ್ಟಿಯನ್ನು ಮಾಡಬೇಕು. ಆದ್ದರಿಂದ ಎರಡು ಪಕ್ಕದ ಅಂಶಗಳು 1 ವ್ಯತ್ಯಾಸದಿಂದ ಭಿನ್ನವಾಗಿದ್ದರೆ ಅದು ಒಂದೇ ಶ್ರೇಣಿಗೆ ಸೇರಿರಬೇಕು. ಮತ್ತೊಂದೆಡೆ, ಎರಡು ಪಕ್ಕದ ಅಂಶಗಳು 1 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಹೊಂದಿದ್ದರೆ, ಅವು ಒಂದೇ ವ್ಯಾಪ್ತಿಗೆ ಸೇರುವುದಿಲ್ಲ.

ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳು ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಪಿನ್

ಈಗ ಅಲ್ಗಾರಿದಮ್ ಸರಳವಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ಪಕ್ಕದ ಅಂಶಗಳಿಗೂ ನಾವು ಸಂಚರಿಸಬೇಕಾಗಿದೆ. ಪಕ್ಕದ ಎರಡು ಸಂಖ್ಯೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವು 1 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ ನಾವು ಎರಡನೇ ಸಂಖ್ಯೆಗೆ ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ಮಾಡಬೇಕಾಗಿದೆ. ಇಲ್ಲದಿದ್ದರೆ ವ್ಯತ್ಯಾಸವು ನಿಖರವಾಗಿ 1 ಆಗಿದ್ದರೆ ನಾವು ಆ ಸಂಖ್ಯೆಯನ್ನು ಒಂದೇ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಇಡುತ್ತೇವೆ.

ಕ್ರಮಾವಳಿ

  1. ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲು ಸ್ಟ್ರಿಂಗ್ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ.
  2. ನಿಂದ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗಲು ಪ್ರಾರಂಭಿಸಿ i = 0 ತನಕ i<N, (N ಎಂಬುದು ರಚನೆಯ ಗಾತ್ರ) a ನಲ್ಲಿ ಲೂಪ್ ಮಾಡುವಾಗ.
    • ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ಗುರುತಿಸಿ ಆರಂಭ ವ್ಯಾಪ್ತಿಯ.
    • ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ವ್ಯೂಹವನ್ನು ಹಾದುಹೋಗಿರಿ ಮತ್ತು ಹಿಂದಿನ ಅಂಶದಿಂದ ವ್ಯತ್ಯಾಸವು ನಿಖರವಾಗಿ 1 ಆಗಿರುವ ಕೊನೆಯ ಅಂಶವನ್ನು ಹುಡುಕಿ ಸಂಖ್ಯೆಗಳು [i + 1] == ಸಂಖ್ಯೆಗಳು [i] +1
    • ಈ ಅಂಶವನ್ನು ಹೀಗೆ ಗುರುತಿಸಿ ಕೊನೆಯಲ್ಲಿ ವ್ಯಾಪ್ತಿಯ.
    • ಈಗ ಈ ರೂಪುಗೊಂಡ ಶ್ರೇಣಿಯನ್ನು ಸೇರಿಸಿ ಫಲಿತಾಂಶ ಪಟ್ಟಿ. ಮತ್ತು ಉಳಿದ ಅಂಶಗಳಿಗೆ ಪುನರಾವರ್ತಿಸಿ.
  3. ಹಿಂತಿರುಗಿ ಫಲಿತಾಂಶ ಪಟ್ಟಿ.
ಸಹ ನೋಡಿ
ಅರೇ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಕಣ್ಮರೆಯಾದ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ಹುಡುಕಿ

ಅನುಷ್ಠಾನ  

ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

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

vector<string> summaryRanges(vector<int>& nums) 
{
    vector<string> res;
    int i=0,n=nums.size();
    while(i<n)
    {
        int start,end;

        start=nums[i];            
        while(i+1<n && nums[i+1]==nums[i]+1) i++;
        end=nums[i];

        if(start==end)
            res.push_back(to_string(start));
        else
            res.push_back(to_string(start) + "->" + to_string(end));

        i++;
    }

    return res;
}

int main() 
{   
    vector<int> nums={0,1,2,4,5,7};
    vector<string> res= summaryRanges(nums);
    
    for(auto str:res) cout<< str <<endl;
    
    return 0; 
}
0->2
4->5
7

ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;
class Rextester{
    
    public static List<String> summaryRanges(int[] nums) 
    {      
        List<String> res= new ArrayList<String>();
        
        int i=0,n=nums.length;
        while(i<n)
        {
            int start,end;
            
            start=nums[i];            
            while(i+1<n && nums[i+1]==nums[i]+1) i++;
            end=nums[i];
            
            if(start==end)
                res.add(start + "");
            else
                res.add( start + "->" + end );
            
            i++;          
        }
        
        return res;
    }
    
  public static void main(String args[])
    {
        int[] nums={0,1,2,4,5,7};
        List<String> res= summaryRanges(nums);
        
        for(String str:res)
            System.out.println(str);
    }
}
0->2
4->5
7

ಸಾರಾಂಶ ಶ್ರೇಣಿಗಳ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ  

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

ಒ (ಎನ್): ಇಲ್ಲಿ N ಎಂಬುದು ನಿರ್ದಿಷ್ಟ ರಚನೆಯ ಗಾತ್ರವಾಗಿದೆ. ನಾವು ಎರಡು ನೆಸ್ಟೆಡ್ ಲೂಪ್ಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ ಪ್ರತಿ ಅಂಶವನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಭೇಟಿ ಮಾಡಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ಒ (ಎನ್) ಆಗಿದೆ.

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

ಒ (1): ತಂತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ನಾವು ಯಾವುದೇ ಸಹಾಯಕ ಸ್ಥಳವನ್ನು ಬಳಸುತ್ತಿಲ್ಲ.

1