Lecture "Brute-force argorithms", exercise 5

[essepuntato]

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

[vattelalberto]

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    if result == expected:
        return True
    else:
        return False

def my_reversed(input_list):
    reversed_list = list()
    n = len(input_list)
    while n > 0:
        reversed_list.append(input_list[n - 1])
        n = n-1
    return reversed_list

print(test_my_reversed(list(["a", "b", "c"]), list(["c", "b", "a"])))
print(test_my_reversed(list(["a", "b", "c", 123, "test"]), list(["test", 123, "c", "b", "a"])))
print(test_my_reversed(list(["a", "b", "c"]), list(["d", 15, "a"])))

[valetedd]

def test_my_reversed(input_list, expected):
    if my_reversed(input_list) == expected:
        return True
    else: 
        return False

def my_reversed(input_list):
    reversed_list = input_list[::-1]
    return reversed_list

print(test_my_reversed(list([0, 1, 2, 3]), list([3, 2, 1, 0])))

Otherwise:

def test_my_reversed(input_list, expected):
    if my_reversed(input_list) == expected:
        return True
    else: 
        return False

def my_reversed(input_list):
    rev_list = list()
    index_list = range(1, len(input_list) + 1)
    for i in index_list:
        rev_list.append(input_list[-i])
    return rev_list

print(test_my_reversed(list([1, 2, 3, 4]), list([4, 3, 2, 1])))

[Liber-R]

[frammenti]

# Test case for the algorithm
def test_my_reversed(input_list,expected):
    result = my_reversed(input_list)
    if expected == result:
        return True
    else:
        return False

# Code of the algorithm
def my_reversed(input_list):
    reversed_list = [] # A new empty list where to store the result
    # List comprehension that iters through index number and appends the negative-1
    # indexed item to the output list (e.g. for index 0 the -1 indexed (last) item)
    reversed_list = [input_list[0-(i+1)] for i in range(len(input_list))]
    return reversed_list

print(test_my_reversed([1, 2, 3, 4], [4, 3, 2, 1])) # True
print(test_my_reversed(["a", "b", "c", "d"], ["d", "c", "b", "a"])) # True
print(test_my_reversed([4, 3, 2, 1], [1, 2, 3, 4])) # True
print(test_my_reversed([0, 1, 0, 1, 1], [1, 1, 0, 1, 0])) # True
print(test_my_reversed([1], [1])) # True
print(test_my_reversed([], [])) # True

[colakogluezgi00]

def my_reversed(input_list):
    reversed_list = list()
    i = len(input_list)
    while i > 0:
        reversed_list.append(input_list[i-1])
        i-=1    
    return reversed_list

def test(input,expectation):
    if input == expectation:
        return True
    else:
        return False

dhdk = ["comp-think","tram","sedt","tesr"]
reversed_dhdk = dhdk[::-1]
print(test(my_reversed(dhdk),reversed_dhdk))

[qwindici]

def my_reversed(input_list):
    reversed_list = []
    for item in input_list:
        reversed_list.insert(0, item)
    return reversed_list

# test function
def test_my_reversed(input_list, expected):
    if my_reversed(input_list) == expected:
        return True
    else:
        return False

# test cases
test_my_reversed([1, 2, 3, 4], [4, 3, 2, 1])
test_my_reversed([], [])
test_my_reversed([3, 2, 1], [1, 2, 3])
test_my_reversed(['Hey'], ['Hey'])

[rufferbaraldi]

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    if expected == result:
        return True
    else:
        return False

def my_reversed(input_list):
    reversed_list = []
    for item in input_list:
        reversed_list.insert(0, item)
    return reversed_list

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

[valentinabertelli]

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    if result == expected:
        return True
    else:
        return False

def my_reversed(input_list):
    result_list = []
    for item in input_list:
      result_list.insert(0, item)
    return result_list    

print(test_my_reversed(([0, 1, 2, 3]), ([3, 2, 1, 0])))  

[enricabruno]

# test function
def test_my_reverse(reverse_number, expected):
    result = my_reverse(reverse_number)
    if result == expected:
        return True
    else:
        return False
# function
def my_reverse(reverse_number):
    reverse_list = list()
    n = 0
    while reverse_number > n:
        reverse_list.append(n)
        n += 1
    return reverse_list

# three tests run
print(test_my_reverse(-1, ([0, 1, 2])))
print(test_my_reverse(2, ([0, 1, 2])))
print(test_my_reverse(3, ([0, 1, 2])))

1° output: False 2nd output: False 3rd output: True

[Sergpoipoip]

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    return result == expected

def my_reversed(input_list):
    res = []
    for i in range(1, len(input_list)+1):
        res.append(input_list[-i])
    return res

print(test_my_reversed(['a', 'b', 'c', 'd'], ['d', 'c', 'b', 'a']))
print(test_my_reversed([0], [0]))

[simocasaz]

from collections import deque

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    if result == expected:
        return True
    else:
        return False

def my_reversed(input_list):
    my_stack = deque()
    my_stack.extend(input_list)
    copied_stack = my_stack.copy()
    reversed_list = list()

    for item in my_stack:
        item = copied_stack.pop()
        reversed_list.append(item)

    return reversed_list

print(test_my_reversed(["Batman", "Superman", "Flash", "Wonder Woman", "Joker", "Cyborg"], ['Cyborg', 'Joker', 'Wonder Woman', 'Flash', 'Superman', 'Batman']))
print(test_my_reversed(["Batman", "Superman", "Batman", "Flash"], ['Flash', 'Batman', 'Superman', 'Batman']))
print(test_my_reversed(["Batman"], ["Batman"]))
print(test_my_reversed([], []))

[CarlaMenegat]

[MariaFrancesca6]

def test_my_reversed(input_list, expected):
    result = my_reversed(input_list)
    if result == expected:
        return True
    else:
        return False

def my_reversed(input_list):
    output_list = list()
    # n is the number of items in the input_list that is the same for the output_list
    # and n is also used for indexing items
    n = len(input_list)
    for item in input_list:
        # appending to the first position of the output_list
        # the item that stands in the last position of the input_list
        output_list.append(input_list[n-1])
        n -= 1
    return output_list

print(test_my_reversed([],[]))
print(test_my_reversed([0,1],[1,0]))
print(test_my_reversed([6,7,8,9],[9,8,7,6]))