CODEWITHSUNDEEP
pythonalgorithm
SleBluue
SleBluue

Reputation: 277

Finding the "centered average" of a list

"Return the "centered" average of a list of integers, which we'll say is the mean average of the values, except ignoring the largest and smallest values in the list. If there are multiple copies of the smallest value, ignore just one copy, and likewise for the largest value. Use integer division to produce the final average. You may assume that the list is length 3 or more."

This is a problem I have from my homework assignment and I am stumped at how to find the the largest/smallest numbers and cut them out of the list. Here is what I have so far. and It works for 10/14 the scenarios that I have to pass.. I think it is just because it grabs the median

def centered_average(nums):
x = 0
for i in range(len(nums)):
    x = i + 0
y = x + 1
if y%2 == 0:
    return (nums[y/2] + nums[(y/2)+1]) / 2
else:
    return nums[y/2]

Upvotes: 2

Views: 15904

Answers (14)

Anthony Onuorah
Anthony Onuorah

Reputation: 1

def centered_average(nums):
    nums.remove((min(nums)))
    nums.remove((max(nums)))
    new_nums=nums
    count = 0
    for i in range(len(new_nums)):
        count+=1
    ans=sum(new_nums)//count
    return ans

Upvotes: 0

Martijn
Martijn

Reputation: 11

New here. I like to check my solutions with solutions found on the internet and did not see my code here yet (hence the post). I found this challenge on https://codingbat.com/prob/p126968. And here is my solution: ** This is done in Python 3.9.1.

First the min and max are popped from the list with the index method. After it's just a simple avg calculation.

def centered_average(nums):

  nums.pop(nums.index(max(nums)))
  nums.pop(nums.index(min(nums)))
  
  return sum(nums)/len(nums)

Upvotes: 1

Rithvik M
Rithvik M

Reputation: 31

Python 3 Solution using list.index, list.pop, min and max functions.

def solution(input):

    average = 0

    minimum = min(input)
    maximum = max(input)

    input.pop(input.index(minimum))
    input.pop(input.index(maximum))

    average =  round(sum(input) / len(input))

    return average

Upvotes: 0

Srinath
Srinath

Reputation: 1

def centered_average(nums):
    sorted_list = sorted(nums)
    return sum(sorted_list[1:-1])/(len(nums)-2)

This will get the job done.

Upvotes: 0

Somebody
Somebody

Reputation: 733

  • use sum function to sum the array

  • max and min functions to get the biggest and smallest number

    def centered_average(nums):
    return (sum(nums) - max(nums) - min(nums)) / (len(nums) - 2)

Upvotes: 0

Thaneesh reddy
Thaneesh reddy

Reputation: 1

simple solution 

def centered_average(nums):
  b=nums

  ma=max(b)
  mi=min(b)

  l=(len(b)-2)

  s=sum(b)-(ma+mi)  
  av=int(s/l)
  return av

Upvotes: 0

Inka
Inka

Reputation: 1

def centered_average(nums):
  min1=nums[0]
  max1=nums[0]
  for item in nums:
    if item > max1:
        max1 = item
    if item < min1:
        min1 = item
  sum1=(sum(nums)-(min1+max1))/(len(nums)-2)
  return sum1

Upvotes: 0

Aleksi Immonen
Aleksi Immonen

Reputation: 1

def centered_average(nums):
    maximums = []
    minimums = []
    sum_of_numbers = 0
    length =len(nums) + (len(minimums)-1) + (len(maximums)-1)
    for i in nums:
        if i == max(nums):
            maximums.append(i)
        elif i == min(nums):
            minimums.append(i)
        else:
            sum_of_numbers += i
    if len(maximums)>=2 or len(minimums)>=2:
        sum_of_numbers = sum_of_numbers + (max(nums)*(len(maximums)-1))(min(nums)*(len(minimums)-1))
    return sum_of_numbers / length

Upvotes: -1

Arpit Patil
Arpit Patil

Reputation: 1

This is a very sub standard solution to the problem. This code is a bad code that does not take into account any consideration for complexity and space. But I think the thought process to be followed is similar to the steps in the code. This then can be refined.

def centered_average(nums):
#Find max and min value from the original list
max_value = max(nums)
min_value = min(nums)
#counters for counting the number of duplicates of max and min values.
mx = 0
mn = 0
sum = 0
#New list to hold items on which we can calculate the avg
new_nums = []
#Find duplicates of max and min values
for num in nums:
  if num == max_value:
    mx += 1
  if num == min_value:
    mn += 1
#Append max and min values only once in the new list
if mx > 1:
  new_nums.append(max_value)
if mn > 1:
  new_nums.append(min_value)
#Append all other numbers in the original to new list
for num in nums:
  if num != max_value and num != min_value:
    new_nums.append(num)
#Calculate the sum of all items in the list
for new in new_nums:
  sum += new
#Calculate the average value.
avg = sum/len(new_nums)

return avg

Upvotes: 0

to_chins
to_chins

Reputation: 11

def centered_average(nums):
  nums = sorted(nums)
  for i in range(len(nums)):
    if len(nums)%2 != 0:
      return nums[len(nums)/2]
    else:
      return ((nums[len(nums)/2] + nums[len(nums)/2 - 1]) / 2)

Upvotes: 0

Ziad Fakhoury
Ziad Fakhoury

Reputation: 197

Before i start i know there are easier ways mentioned in the other answers using the function sort, yes that is true but i believe your teacher must have iven you this to able to master loops and use them logically.

First pick your first number and assign it to high and low, don't worry it will make sense afterwards.

def centered average(nums):

high = nums[0]
small = nums[0]

Here is were the magic happens, you loop through your list and if the number your on in the loop is larger then the previous ones then you can replace the variable high with it, let me demonstrate.

for count in nums:
    if count > high:
        high = count
    if count < low:
        low = count

Now you have the low and the high all you do is add the values of the loop together minus the high and the low (as you said you do not need them).Then divide that answer by len of nums.

for count in nums:
    sum = count + sum
sum = sum - (high + low)
return sum

Upvotes: 1

SirGuy
SirGuy

Reputation: 10770

Sorting the array is certainly terser code, here's an alternative with a manual loop

    max_value = nums[0]
    min_value = nums[0]
    sum = 0
    for x in nums:
        max_value = max(max_value, x)
        min_value = min(min_value, x)
        sum += x

    return (sum - max_value - min_value) / (len(nums) - 2)

This just adds everything in and removes the max and min at the end.

Upvotes: 7

crow_t_robot
crow_t_robot

Reputation: 524

If I understand the question, this should work: 

def centered_average(nums):
  trim = sorted(nums)[1:-1]
  return sum(trim) / len(trim)

Upvotes: 0

Simon Fraser
Simon Fraser

Reputation: 2818

If the list isn't too long, it shouldn't be too computationally expensive to sort the list:

sorted(nums)

Then you can create a new list without the first and last entries, which will be the smallest and largest values:

new_nums = sorted(nums)[1:-1] # from index 1 to the next-to-last entry

Upvotes: 1

Related Questions