Lecture "Brute-force argorithms", exercise 3

[essepuntato]

Write in Python the function def my_enumerate(input_list), which behaves like the built-in function enumerate() introduced in Section "Linear search" and returns a proper list, and accompany the function with the related test case. It is not possible to use the built-in function enumerate() in the implementation.

[ManuSrivastava1]

Here is my version of enumerate function.

def my_enumerate(input_list):
    x = len(input_list)
    y= 0
    output_list = []
    while y <= x-1:
        output_tuple = (y,input_list[y])
        output_list.append(output_tuple)
        y += 1
    return output_list

Here is the visualization of how the function works

Below is the test code for the above written algorithm -

def test_my_enumerate(input_list,output_list,expected):
    n=0
    while n < len(input_list):
        item_from_list = output_list[n]
        if item_from_list[1]==input_list[n] and item_from_list[0]==n:
            result = True
        else:
            result = False
            break
        n+= 1
    if expected == result:
        return True
    else:
        return False
        
g = test_my_enumerate(['f','g','h'],[(0,'f'),(1,'g'),(2,'h')],True)
k = test_my_enumerate(['f','g','h'],[(0,'f'),(1,'h'),(2,'h')],False) 

Here you can see the test code in action

note: I don't think this is the most elegant or even the complete method for testing the algorithm, but its the best I could come up with.

[RebeccaJillianBeattie]

[chloeppd]

[CarmenSantaniello]

def test_my_enumerate(input_list, expected):
    result = my_enumerate(input_list)
    if expected == result:
        return True 
    else:
        return False

my_list = ["Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"]

def my_enumerate(input_list):
    output_list = list()
    for item in input_list:
        my_tuple = (input_list.index(item), item)
        output_list.append(my_tuple)
    return output_list

print(test_my_enumerate(my_list, [(0, "Gryffindor"), (1, "Hufflepuff"), (2, "Ravenclaw"), (3, "Slytherin")]))
print(my_enumerate(my_list))

It returns:

True
[(0, 'Gryffindor'), (1, 'Hufflepuff'), (2, 'Ravenclaw'), (3, 'Slytherin')]

[federicabonifazi]

def test_my_enumerate(input_list, expected):
    result=my_enumerate(input_list)
    if expected == result:
        return True
    else:
        return False

def my_enumerate(input_list):
    enumerated_list = list()
    for item in input_list:
        enumerated_list.append ((input_list.index(item), item))
    return enumerated_list

print (test_my_enumerate(["a", "b", "c", "d"], [(0,"a"), (1,"b"), (2,"c"), (3,"d")]))

[olgagolgan]

[martasoricetti]

[ManueleVeggi]

#Test case for the algorithm
def test_my_enumerate(input_list, expected_list):
    result = my_enumerate(input_list)
    if result == expected_list:
        return True
    else:
        return False

#Code of the algorithm
def my_enumerate(input_list):
    output_list = []
    for element in input_list:
        position = input_list.index(element)
        singletuple = (position, element)
        output_list.append(singletuple)     
    return output_list

#Test 1. Expect: T
in_list1 = list(["a","b","c"])
ex_list1 = list([(0, "a"), (1, "b"), (2, "c")])
print(test_my_enumerate(in_list1, ex_list1))

#Test 2. Expect: F
in_list2 = list(["a","b","d"])
ex_list2 = list([(0, "a"), (1, "b"), (2, "c")])
print(test_my_enumerate(in_list2, ex_list2))

#Test 3. Expect: F
in_list3 = list(["a","b","c"])
ex_list3 = list([(1, "a"), (2, "b"), (3, "c")])
print(test_my_enumerate(in_list3, ex_list3))

If the code is run, the results True, False, False: as a consequence, the code should be correct

[OrsolaMBorrini]

def test_my_enumerate(input_list, expected):
    result = my_enumerate(input_list)
    if result == expected:
        return True
    else:
        return False

def my_enumerate(input_list):
    result = list()
    for item in input_list:
        my_tuple = (input_list.index(item),item)
        result.append(my_tuple)
    return result

# Test 1
example_list = ["Alpha","Gamma","Beta"]
example_expected = [(0,"Alpha"),(1,"Gamma"),(2,"Beta")]
print(test_my_enumerate(example_list,example_expected)) # It should return True

print(my_enumerate(example_list))
# This correctly returns [(0, "Alpha"), (1, "Gamma"), (2, "Beta")]

# Test 2
example_list2 = ["Long John Silver", "Flint", "Jim Hawkins"]
example_expected2 = [(0,"Long John Silver"), (1,"Flint")]
print(test_my_enumerate(example_list2,example_expected2)) # It should return False, as one item is missing

[tommasobattisti]

def test_my_enumerate(input_list, expected):
    result = my_enumerate(input_list)
    if result == expected:
        return True
    else:
        return False

def my_enumerate(input_list):
    output_p_list = []
    for i in input_list:
        output_p_list.append((input_list.index(i), i))
    return output_p_list

print(test_my_enumerate(['a', 'b', 'c', 'd'],[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]))
print(test_my_enumerate(['red', 'purple', 'black', 'green'],[(0, 'red'), (1, 'purple'), (2, 'black'), (3, 'green')]))

[MaddaGh]

[NoraPs]

[katya-avem]

[AnastasiyaSopyryaeva]

Task_3

def testing(input_list, expected):
    result = my_enumerate(input_list)
    if result == expected:
        return True
    else:
        return False

def my_enumerate(input_list):
    output = []
    for item in input_list:
        output.append((input_list.index(item), item))
    return output

print(testing(['a', 'b', 'c'], [(0, 'a'), (1, 'b'), (2, "c")]))
print(testing(['Italy', 'Spain', 'Germany', 'Norway'], [(0, 'Italy'), (1, 'Spain'), (2, 'Norway'), (3, 'Germany')]))

Returns
True
False