ಶೂನ್ಯ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದವರೆಗೆ ಎನ್ ವಿಶಿಷ್ಟ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವನ್ನು ಹುಡುಕಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಡೋಬ್ ಅಮೆಜಾನ್ ಫೇಸ್ಬುಕ್ ಮೈಕ್ರೋಸಾಫ್ಟ್
ಅರೇ

N ೀರೋ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದವರೆಗಿನ ಎನ್ ಅನನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಸಮಸ್ಯೆ, ನಮಗೆ ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಒದಗಿಸುತ್ತದೆ. 0 ರವರೆಗಿನ n ಅನನ್ಯ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು ಇದು ನಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪ್ರಶ್ನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಹಳ ಸರಳವಾಗಿದೆ. ಆದ್ದರಿಂದ, ದ್ರಾವಣಕ್ಕೆ ಧುಮುಕುವ ಮೊದಲು. ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಶೂನ್ಯ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದವರೆಗೆ ಎನ್ ವಿಶಿಷ್ಟ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವನ್ನು ಹುಡುಕಿ

n = 5
[-7,-1,1,3,4]

ವಿವರಣೆ: ಸರಿ, ಸಮಸ್ಯೆಗೆ ಅನೇಕ uts ಟ್‌ಪುಟ್‌ಗಳು ಇರಬಹುದು. ಆದರೆ ಕೊಟ್ಟಿರುವ .ಟ್‌ಪುಟ್ ತೆಗೆದುಕೊಳ್ಳೋಣ. Output ಟ್‌ಪುಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕಗಳು ಅನನ್ಯವಾಗಿವೆ. ಹೀಗೆ ಹೇರಿದ ಸ್ಥಿತಿಯನ್ನು ತೃಪ್ತಿಪಡಿಸುವುದು ಮತ್ತು ಕೊಟ್ಟಿರುವ ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತ 0. ಆದ್ದರಿಂದ, ಎರಡೂ ಷರತ್ತುಗಳು ತೃಪ್ತಿಕರವಾಗಿವೆ.

n = 3
[-1, 0, 1]

ವಿವರಣೆ: ನೀಡಿರುವ output ಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ವಿಶಿಷ್ಟ ಪೂರ್ಣಾಂಕಗಳಿವೆ ಮತ್ತು ಅವುಗಳ ಮೊತ್ತವೂ 0 ಆಗಿದೆ. ಹೀಗಾಗಿ, ಹೇರಿದ ಎಲ್ಲಾ ಷರತ್ತುಗಳನ್ನು output ಟ್‌ಪುಟ್ ಪೂರೈಸುತ್ತದೆ.

ಫೈಂಡ್ ಎನ್ ಅನನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ವಿಧಾನ ಶೂನ್ಯ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದವರೆಗೆ

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

ಎನ್ ಅನನ್ಯ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವ ಕೋಡ್ ಶೂನ್ಯ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದವರೆಗೆ

ಸಿ ++ ಕೋಡ್

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

vector<int> sumZero(int n) {
    vector<int> v(n);
    for(int i=0;i<n;i++)
        v[i] = 2*i - n + 1;
    return v;
}

int main(){
    vector<int> output = sumZero(7);
    for(auto x: output)
        cout<<x<<" ";
}
-6 -4 -2 0 2 4 6

ಜಾವಾ ಕೋಡ್

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

class Main
{
    public static int[] sumZero(int n) {
        int[] v = new int[n];
        for(int i=0;i<n;i++)
            v[i]= 2*i - n + 1;
        return v;
    }
    
    public static void main(String[] args){
    	int[] output = sumZero(7);
    	for(int i=0;i<7;i++)
    		System.out.print(output[i]+" ");
    }
}
-6 -4 -2 0 2 4 6

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

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

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

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

ಒ (ಎನ್), ಏಕೆಂದರೆ ನಾವು a ಟ್‌ಪುಟ್‌ನಂತೆ ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ.