අවම සහ උපරිම වැටුප් ලීට්කෝඩ් විසඳුම හැර සාමාන්‍ය වැටුප


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ NetSuite
ලීට්කෝඩ්

ගැටළු ප්රකාශය

ගැටලුවේ ” සාමාන්ය අවම හා උපරිම වැටුප් හැර වැටුප් ”අපට වැටුප් පෙළක් ලබා දී ඇත. එහිදී අරාවෙහි ඇති සෑම අංගයක්ම විවිධ සේවකයින්ගේ වැටුප නියෝජනය කරයි. අරාවෙහි සෑම අගයක්ම අද්විතීය වේ.

අපගේ කර්තව්‍යය වන්නේ අවම හා උපරිම වැටුප හැර සේවකයාගේ සාමාන්‍ය වැටුප ගණනය කිරීමයි.

උදාහරණයක්

Salary= [8000,9000,2000,3000,6000,1000]
4750.0

පැහැදිලි කිරීම:

අවම සහ උපරිම වැටුප් ලීට්කෝඩ් විසඳුම හැර සාමාන්‍ය වැටුප

ලබා දී ඇති වැටුප් අරාවෙහි 9000 උපරිම වැටුප වන අතර 1000 අවම වැටුප වේ. අප හැර සාමාන්‍ය වැටුප සොයා ගත යුතුය අවම සහ උපරිම වැටුප නිසා අපි මෙම අගයන් මුළු එකතුවට එකතු නොකරමු. මුළු මුදල 19000 ක් වන අතර සාමාන්‍යය 19000/4 එනම් 4750 කි.

ප්රවේශය

මෙය මූලික ගණිත ගැටලුවකි. අපගේ කර්තව්‍යය වන්නේ අවම සහ උපරිම වැටුප සොයා ගැනීම සහ ඉතිරි වැටුපෙහි සාමාන්‍යය සොයා ගැනීමයි. අපි මෙම පියවර අනුගමනය කරන්නෙමු:

  1. අවම වැටුප INT_MAX සමඟ ආරම්භ කරන්න, INT_MIN සමඟ උපරිම වැටුප. වැටුප් එකතුව ගබඩා කිරීම සඳහා අපි විචල්‍යයක් භාවිතා කරන්නෙමු, එබැවින් එය 0 සමඟ ආරම්භ කරන්න.
  2. අරාව හරහා ගමන් කර එක් එක් වැටුප එකතුවට එකතු කරන්න. මේ අතර, අවම වැටුප සහ උපරිම වැටුපෙහි වටිනාකම ද යාවත්කාලීන කරන්න.
  3. N හි අගය තුනකට වඩා කුඩා නම් සාමාන්‍ය වැටුප ශුන්‍ය වේ නම් සාමාන්‍ය වැටුප වනු ඇත (මුළු වැටුප - අවම වැටුප - උපරිම වැටුප) / (n-2).
  4. සාමාන්‍ය වැටුප දෙගුණයක් විය හැකි නිසා අපි (n-2) 1.0 සමඟ ගුණ කරන්නෙමු.

අවම සහ උපරිම වැටුප් ලීට්කෝඩ් විසඳුම හැර සාමාන්‍ය වැටුප් සඳහා කේතය

සී ++ කේතය

#include <bits/stdc++.h> 
using namespace std; 
       double average(vector<int>& salary) {
        int n=salary.size();
        int mn=INT_MAX,mx=INT_MIN,sum=0;
        for(int i=0;i<n;i++)
        {
            sum=sum+salary[i];
            mn=min(mn,salary[i]);
            mx=max(mx,salary[i]);
        }
        double ans=(sum-mn-mx)/((n-2)*1.0);
        if(n>2)
            return ans;
        else 
            return 0;
    }
int main() 
{ 
 vector<int> arr = {8000,9000,2000,3000,6000,1000}; 
 cout<<average(arr)<<endl; 
 return 0;
}
4750.0

ජාවා කේතය

import java.util.Arrays; 
public class Tutorialcup {
        public static double average(int[] salary) {
        int n=salary.length;
        int mn=Integer.MAX_VALUE,mx=Integer.MIN_VALUE,sum=0;
        for(int i=0;i<n;i++)
        {
            sum=sum+salary[i];
            mn=Math.min(mn,salary[i]);
            mx=Math.max(mx,salary[i]);
        }
        double ans=(sum-mn-mx)/((n-2)*1.0);
        if(n>2)
            return ans;
        else 
            return 0;
    }
  public static void main(String[] args) {
    int [] arr = {8000,9000,2000,3000,6000,1000}; 
    double ans=  average(arr);
    System.out.println(ans);
  }
}
4750.0

අවම සහ උපරිම වැටුප් ලීට්කෝඩ් විසඳුම හැර සාමාන්‍ය වැටුප පිළිබඳ සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

ඉහත කේතයේ කාල සංකීර්ණතාව වේ සාමාන්ය (n) මොකද අපි වැටුප් රේඛාව හරහා ගමන් කරන්නේ එක් වරක් පමණයි. මෙන්න n යනු වැටුප් අරාවේ දිගයි.

අවකාශයේ සංකීර්ණතාව

ඉහත කේතයේ අවකාශය සංකීර්ණ වේ ඕ (1) මොකද අපි උත්තරය ගබඩා කරන්න විචල්‍යයක් විතරයි පාවිච්චි කරන්නේ.

ආශ්රිත