ചില ഘടകങ്ങൾ ലീറ്റ്കോഡ് പരിഹാരം നീക്കം ചെയ്തതിനുശേഷം അറേയുടെ അർത്ഥം


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു ഗൂഗിൾ
അറേ

പ്രശ്നം പ്രസ്താവന

“ചില ഘടകങ്ങൾ നീക്കംചെയ്‌തതിനുശേഷം അറേയുടെ അർത്ഥം” എന്ന പ്രശ്‌നത്തിൽ ഞങ്ങൾക്ക് ഒരു ശ്രേണി നൽകുന്നു. അറേയുടെ എല്ലാ ഘടകങ്ങളും പോസിറ്റീവ് സംഖ്യകളാണ്. അറേയുടെ വലുപ്പം 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. ഇതിനായി, ഞങ്ങൾ n * 0.05 ൽ നിന്ന് ലൂപ്പ് സമാരംഭിക്കും, ഇവിടെ n എന്നത് നൽകിയിരിക്കുന്ന അറേയുടെ നീളം, ഒപ്പം ലൂപ്പ് n * 0.95 വരെ പ്രവർത്തിക്കും.
  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 ആണ്.

സ്ഥല സങ്കീർണ്ണത

മുകളിലുള്ള കോഡിന്റെ സ്ഥല സങ്കീർണ്ണത O (1) കാരണം ഉത്തരം സംഭരിക്കാൻ ഞങ്ങൾ ഒരു വേരിയബിൾ മാത്രമാണ് ഉപയോഗിക്കുന്നത്.

അവലംബം