אתגר: הפונקציה flatten

נסו לכתוב פונקציה קצרה בשם flatten שמקבלת רשימה בעומק בלתי מוגבל, ומחזירה רשימה שטוחה.

לדוגמה:

עבור: [[[1, 2], [3, 4]], [5, 6], 7] יוחזר: [1, 2, 3, 4, 5, 6, 7].
עבור: [[]] יוחזר: [].

בונוס למי שמצליח לכתוב 2 פונקציות: אחת רקורסיבית והשנייה לא רקורסיבית.

5 לייקים
גרסא מכוערת 2
def flatten(lst_of_lsts):
lst = []
for elem in lst_of_lsts:
	if isinstance(elem, list):
		lst.extend(flatten(elem))
	else:
		lst.append(elem)
return lst
2 לייקים

אפשר יותר פשוט בלי פונקציה בכלל

גרסה ממש מכוערת
a = str(my_list).replace('[', '').replace(']', '').replace(',', ' ').split()

הערה: החלק האחרון נועד למנוע איברים ריקים ברשימה

2 לייקים

משעשע למדי, אבל:

  1. אתה הופך את האיברים ברשימה למחרוזות, מה שאומר שאלה כבר לא האיברים המקוריים.
  2. זה פועל פחות טוב אם יש לך איברים שאינם int/float ברשימה, למשל tuple או מחרוזת.
3 לייקים

שתי גרסאות ממש ממש מכוערות (רק ממשיכה את הרצף מעליי)

גרסה רקורסיבית
def flatten(nested_list):
    while check_if_nested(nested_list):
        next_level = []
        for item in nested_list:
            if isinstance(item, list):
                next_level.extend(item)
            else:
                next_level.append(item)
        return flatten(next_level)
    return nested_list


def check_if_nested(items):
    for item in items:
        if isinstance(item, list):
            return True


# Some tests
# example_list = [[[[1, 2], [3, 4]]], [[5, 6]], 7, [8]]
# empty_nested_list = [[[]]]
# non_nested_list = [1, 2, 3]
# print(flatten(example_list))
# print(flatten(empty_nested_list))
# print(flatten(non_nested_list))
גרסה איטרטיבית
def flatten(nested_list):
    current_level = nested_list.copy()
    next_level = []
    while check_if_nested(current_level):
        for item in current_level:
            if isinstance(item, list):
                for i in item:
                    next_level.append(i)
            else:
                next_level.append(item)
        current_level = next_level
        next_level = []
    return current_level


def check_if_nested(items):
    for item in items:
        if isinstance(item, list):
            return True


# Some tests
# example_list = [[[[1, 2], [3, 4]]], [[5, 6]], 7, [8]]
# empty_nested_list = [[[]]]
# non_nested_list = [1, 2, 3]
# print(flatten(example_list))
# print(flatten(empty_nested_list))
# print(flatten(non_nested_list))
3 לייקים

זה. הצחיק אותי ממש! :joy:
תודה. :heart:

פתרון
def flatten_recursive(l):
    temp = []
    for i in l:
        if isinstance(i, list):
            temp.extend(flatten(i))
        else:
            temp.append(i)
    return temp


def flatten(l):
    temp = l.copy()
    while len(tuple(filter(lambda k: isinstance(k, list), temp))) != 0:
        new = []
        for i in temp:
            if isinstance(i, list):
                for j in i:
                    new.append(j)
            else:
                new.append(i)
        temp = new.copy()
    return temp

# Tests
L1 = [[[1, 2], [3, 4]], [5, 6], 7]
L2 = [[]]

print()
print(flatten(L1))
print(flatten(L2))
print()
print(flatten_recursive(L1))
print(flatten_recursive(L2))