Udacity CS101: Lesson 8 - Problem Set (Optional 2)

The two are roughly equivalent in terms of what they do. You are looping until you break, whereas the second solution always loops to what it knows to be the maximum number of loops needed (unless it finds the failure case) - the length of the product argument. Both will run in the same O(n) amount of time, so while you have some awkwardness in your code it's not practically different.

There are other approaches to go about this that are clearer to understand. For instance, since you don't care about repeat variables, it might be easier to take your product as input to a set:

required_characters = {c for c in product}  # puts all characters into a set, dropping repeats (because sets can only have a given value once)
for c in required_characters:
    if c not in debris:
        return "Give me something that's not useless next time."
return product

The functional difference here is that you are looping through product once, and can stop looping through debris the moment you find all the characters. But this also runs in O(n) - which is as fast as you can actually do this. The real question is what is clearest to you, the programmer, and clearest to whomever reads your code.

In the comments, @alani notes that you can also do something like this:

if set(product) <= set(debris):
    return product
return "Give me..."

This does something similar, using set comparison. The slight downside here is that you're putting both inputs into sets (an O(n) operation), which means you're guaranteed the maximum runtime - nothing will quit early if it knows it is a condition that can't be satisfied. Still, it is even more concise and therefore clear. For reasonable inputs a totally valid approach.

while loops can be used for any type of looping but for situations where you're iterating over a collection (like the letters in a word) a for loop is much more appropriate. Generally a while loop is more useful when you don't know in advance how many times the loop will execute.

Here's a sample of iterating through both words looking for a letter in product that doesn't appear in debris:

NOT_FOUND_MSG = "Give me something that's not useless next time."

def fix_machine(debris, product):
    for p_char in product:
        found = False
        for d_char in debris:
            if p_char == d_char:
                found = True
                break
        if not found:
            return NOT_FOUND_MSG
    return product

We can clarify (and maybe optimize) by using in to check if p_char is in debris without explicitly iterating over it:

def fix_machine(debris, product):
    for p_char in product:
        if p_char not in debris:
            return NOT_FOUND_MSG
    return product

Let's trim it down some more by using an alternate form of the for loop:

def fix_machine(debris, product):
    if any(p_char not in debris for p_char in product):
        return NOT_FOUND_MSG
    return product

Finally an alternative which eliminates explicit loops altogether by taking advantage of the properties of a set:

def fix_machine(debris, product):
    return product if set(product).issubset(debris) else NOT_FOUND_MSG

I'm going to answer this under the assumption this is part of an exercise on while loops.

Your solution was a good attempt, but there are a few things that you can still improve. I'm going to walk through your code and point them out.

def fix_machine(debris, product):
    i = -1        # THING 1
    while True:
        i = i +1  # ALSO THING 1
        if debris.find(product[i]) == -1:
            return "Give me something that's not useless next time."
            break # THING 2
        word = product[0:i+1] # THING 3
        if word == product:
            break
    return word

Thing 1: Initializing your index variable like this may work, but it isn't very clean. Instead you should do what the example you provided did and initialize to zero then increment at the end of your loop. This is easier to read and better practice overall.

Thing 2: This break statement will never be reached. The return statement will end your function (and by extension, the loop).

Thing 3: This is a clever idea, but a better idea would be to break once you've iterated over the entirety of the product. That way you don't have to check for equality every iteration.

If you fix all of these you'll notice you end up with the second example:

def fix_machine(debris, product):
    x = 0 #THING 1 (Initialize to zero)
    while x < len(product): #THING 3 (stop at end of product)
        if debris.find(product[x]) == -1:
            return "Give me something that's not useless next time." # THING 2 (no break)
        x += 1 # THING 1(INCREMENT AT END)
    return product