Hello, @mauroborgesm.
Consider your while
loop:
while new_list < 9000:
What if the list is empty or doesn’t have elements that will add up to 9000? How do you exit the loop?
Hello, @mauroborgesm.
Consider your while
loop:
while new_list < 9000:
What if the list is empty or doesn’t have elements that will add up to 9000? How do you exit the loop?
Hi there! I used this as my solution to the challenge presented:
#Write your function here
def over_nine_thousand(lst):
lst_sum = 0 index = 0 while lst_sum < 9000: lst_sum += lst[index] index += 1 if index == len(lst) - 1: index = 0 else: continue return lst_sum
#Uncomment the line below when your function is done
print(over_nine_thousand([8000, 900, 120, 5000]))
The answer comes out to the correct 9020, and no error is displayed, however the program returns this: over_nine_thousand([8000, 900])
should have returned 8900
, and it returned 8000. I was wondering if anyone could explain this phenomenon to me?
so first index is zero:
index = 0
then you increase the index by one:
index += 1
so now, index
has a value of 1
then here:
if index == len(lst) - 1:
len(lst) is 2. so then we get:
if 1 == 2 - 1
doing the math:
if 1 == 1
1 equals 1 seems true.
Here is my solution.
def over_nine_thousand(lst):
if not lst:
return 0
total_sum = 0
for num in lst:
total_sum += num
if total_sum > 9000:
return total_sum
elif sum(lst) < 9000:
return sum(lst)
Probably shouldn’t sum the whole list more than once.
Also, after finishing your loop you’ll have acquired the sum, so there’s no reason to use the built-in sum function
Thanks for the tip, I will try to optimize the code more.
Hi all,
Please could you let me know why this solution is not accepted? I’ve included a screenshot of my code below. It runs without errors and is returning the value expected - which is the sum of indices in the list starting at position 0 up to (and including) the value at index position n that results in the sum being greater than 9000.
I’ve probably missed something obvious and will be back to delete this post when I realise it! In the meantime, any assistance would be greatly appreciated.
Thanks
edit:
To make matters more confusing - I noticed there might be an issue if the sum of all indices in the given list never exceeded 9000, so I added a ‘break’ command if the length of the remaining list was equal to 0. When I did this, the guidance at the foot of the screen told me the answer should be something different to what was outlined in the instructions (and what I was getting when I ran the program).
The instructions say:
if the list is empty, the function should return 0
.
Your function returns an empty list when the list is empty (line 4 and 5)
Yes I see, obvious when you point it out…! Thanks
if you sum an empty list you get 0, that’s not a special case that you need code for
you don’t need to modify a list to read from it
removing at the front of a list is as much work as copying the whole list
Can anybody let me know why my code is not working as expected?
Thanks!
> def over_nine_thousand(lst):
>
> sum1 = 0
>
> i = 0
>
> while sum1 < 9000:
>
> sum1 += lst[0]
>
> i += 1
>
> return sum1
Thanks… I think that is an error it should be below and it should work,
def over_nine_thousand(lst):
sum1 = 0
i = 0
while sum1 < 9000:
sum1 += lst[i] i += 1
return sum1
Well, that’s an improvement for sure, but is the condition of your while
loop going to work in all cases? What if the list were empty, or doesn’t contain values that add up to 9000 or more? Maybe a while
loop isn’t the best tool for this task?
I was looking over the solutions by other people and noticed that mine didn’t use a while loop but was still correct. Is my code incorrect?
def over_nine_thousand(lst):
sum = 0
for num in lst:
if sum < 9000:
sum += num
return sum
Hello, @uglyerick, and welcome to the Codecademy Forums!
The instructions ask for the total to exceed 9000
. The following is part of the instructions:
The function should sum the elements of the list until the sum is greater than
9000
.
What result does your function produce if sum
becomes equal to 9000
before it has processed all the items in lst
?
I see, thank you, so by changing it to >= my code would be correct even if it doesn’t use a while loop with a break as recommended by the hint?
Hi @uglyerick,
Are you sure that >=
is the correct comparison operator?
To find out whether that works, test the function with a variety of cases, and display the results. Refine the code, if necessary. See the thread Help with over 9000 for some suggested cases.
Edited on May 24, 2020 to focus attention on the comparison operator
def over_nine_thousand(lst):
sum = 0
while sum < 9000:
for x in lst: sum += x
return sum
#Uncomment the line below when your function is done
print(over_nine_thousand([8000, 900, 120, 5000]))
I’m getting 14020 as an answer instead of 9020. What am I doing wrong?
the for loop will sum all the values from the list.
Once the for loop gets started, the while loop will run after the for loop looped over the entire list
you really shouldn’t need two loops, we only need one loop until we have reached 9000 (or not). Why would that require two loops?