काही घटकांचा लेटकोड सोल्यूशन काढल्यानंतर अ‍ॅरेचा मीन


अडचण पातळी सोपे
वारंवार विचारले Google
अरे

समस्या विधान

"काही घटक काढल्यानंतर अ‍ॅरे ऑफ अ‍ॅरे" या समस्येमध्ये आम्हाला अ‍ॅरे दिले जातात. अ‍ॅरेचे सर्व घटक सकारात्मक पूर्णांक आहेत. अ‍ॅरेचा आकार 20 च्या एकाधिक आहे.

अ‍ॅरेचा अर्थ शोधणे हे आपले कार्य आहे वगळता सर्वात लहान 5% घटक आणि सर्वाधिक 5% घटक.

उदाहरण

arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]
4.000000

स्पष्टीकरण:

काही घटकांचा लेटकोड सोल्यूशन काढल्यानंतर अ‍ॅरेचा मीन

क्रमवारी लावल्यानंतर दिलेली अ‍ॅरे इमेज दाखवते. सर्वात जास्त आणि सर्वात कमी 5% घटक काढून टाकल्यानंतर, उर्वरित घटकाची बेरीज 172 आहे आणि उर्वरित घटकांची एकूण संख्या 36 आहे. तर अर्थ 4.77778 होतो.

काही घटकांचा लेटकोड सोल्यूशन काढल्यानंतर मीन ऑफ अ‍ॅरेसाठी दृष्टीकोन

अंमलबजावणीची ही एक सोपी समस्या आहे. खाली या समस्येचे निराकरण करण्यासाठी चरण आहेतः

  1. आपल्याला अ‍ॅरेमधून सर्वाधिक आणि सर्वात कमी 5% घटक ट्रिम करण्याची आवश्यकता असल्यामुळे दिलेल्या अ‍ॅरेची क्रमवारी लावा.
  2. व्हेरिएबलमध्ये अ‍ॅरेची लांबी साठवा.
  3. दोन चल घोषित करा:
    1. घटकांची बेरीज संचयित करण्यासाठी.
    2. मधे घटकांची संख्या संग्रहित करणे.
  4. आता एक लूप चालवा आणि सुव्यवस्थित घटकांची बेरीज शोधा.
    1. त्यासाठी एन * ०.०0.05 वरून लूप सुरू करू जेथे एन दिलेली अ‍ॅरेची लांबी आहे आणि लूप एन * ०.0.95 till पर्यंत चालेल.
  5. सरासरीची गणना करा.
    1.  येथे लक्षात घेण्याचा एक महत्त्वाचा मुद्दा म्हणजे त्याने पूर्णांक मूल्य नव्हे तर दुप्पट मूल्य परत करावे.

अंमलबजावणी

काही घटक काढल्यानंतर मीन ऑफ अ‍ॅरेसाठी सी ++ कोड

#include <bits/stdc++.h> 
using namespace std; 
    double trimMean(vector<int>& arr) {
        sort(arr.begin(),arr.end());
        int n=arr.size();
        double sum=0,cnt=0;
        for(int i=(n*.05);i<n*.95;i++)
        { 
            sum+=arr[i];
            cnt++;
        }
        return sum/cnt;      
    }
int main() 
{ 
 vector<int> arr = {6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4}; 
 double ans=trimMean(arr);
 cout<<ans<<endl;
 return 0;
}
4.77778

काही घटक काढल्यानंतर मीन ऑफ अ‍ॅरेसाठी जावा कोड

import java.util.Arrays; 
public class Tutorialcup {
    public static double trimMean(int[] arr) {
     Arrays.sort(arr);
     int n = arr.length;   
     double sum = 0d,cnt=0; 
     for(int i=n / 20;i<n - n / 20;i++)
        { 
            sum+=arr[i];
            cnt++;
        }
        return sum/cnt; 
    }
  public static void main(String[] args) {
        int [] arr = {6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4}; 
        double ans=trimMean(arr); 
        System.out.println(ans);
  }
}
4.77778

काही घटकांचे लेटकोड सोल्यूशन काढल्यानंतर मीन ऑफ अ‍ॅरेचे जटिलता विश्लेषण

वेळ गुंतागुंत

वरील कोडची वेळ जटिलता आहे O (nlogn) कारण आपण दिलेली अ‍ॅरे सॉर्ट करत आहोत. येथे n दिलेली अ‍ॅरेची लांबी आहे.

जागेची जटिलता

वरील कोडची स्पेस कॉम्प्लेक्सिटी आहे ओ (1) कारण आम्ही उत्तर संग्रहित करण्यासाठी फक्त एक व्हेरिएबल वापरत आहोत.

संदर्भ