עזרה במציאת איברי יחודיים ברשימות

החלק העצוב שמישהו טוען שהוא מצא אלגוריתם ב 2 דקות אבל מסרב לשתף

מילון שבו אתה מחזיק לכל אינדקס איזה מספרים כבר הופיעו בו?

עכשיו הבנתי. כלומר עבור 1111 אתה יכול לקבל רשימות שאין בהם 1 אבל אין בעיה שבתוכן יש מספרים שחוזרים על עצמם.

השאלה היא עכשיו אם אתה רוצה לבדוק את כל הצירופים האפשריים עבור כל רשימה ? ואם כן, האם היא יכולה להיות משוות לרשימות ב"קבוצה" שלה או שאם אני לוקח רשימה מהקבוצה הראשון, אני יכול למצוא לה את הקומבינציות רק מקבוצות האחרות ?

סליחה על כל השאלות פשוט מנסה להבין את התרגיל.

מחפש לפחות תשובה אחת נכונה ויכול לשלוף רק איבר אחד מכל משתנה (a, b, c, d).
תארתי לעצמי שיהיה מסובך להסביר את התרגיל
אני מפורק מזה כבר

תרשום פה בצורה של קוד את המשתנים abcd שנוכל להעתיק ליופיטר.

a = [[3, 3, 3, 2], [2, 1, 3, 4], [1, 3, 4, 3], [3, 3, 2, 3], [3, 2, 3, 3], [2, 3, 3, 3],
[1, 3, 4, 2], [3, 4, 2, 1], [4, 2, 1, 3], [3, 4, 3, 1], [4, 3, 1, 3], [3, 1, 3, 4]]

b = [[3, 3, 1, 4], [1, 1, 3, 2], [1, 4, 2, 3], [3, 1, 4, 3], [1, 4, 3, 3], [4, 3, 3, 1],
[1, 3, 2, 1], [3, 2, 1, 1], [2, 1, 1, 3], [4, 2, 3, 1], [2, 3, 1, 4], [3, 1, 4, 2]]

c = [[1, 3, 4, 4], [3, 2, 4, 2], [1, 2, 4, 2], [3, 4, 4, 1], [4, 4, 1, 3], [4, 1, 3, 4],
[2, 4, 2, 3], [4, 2, 3, 2], [2, 3, 2, 4], [2, 4, 2, 1], [4, 2, 1, 2], [2, 1, 2, 4]]

d = [[3, 2, 2, 1], [1, 2, 4, 1], [1, 3, 4, 2], [2, 2, 1, 3], [2, 1, 3, 2], [1, 3, 2, 2],
[2, 4, 1, 1], [4, 1, 1, 2], [1, 1, 2, 4], [3, 4, 2, 1], [4, 2, 1, 3], [2, 1, 3, 4]]

פעם הבאה תעשה ככה:

הרבה יותר פשוט לעזור ככה.

זה נשמע לי כמו מקרה קלאסי של XY Problem.
רוצה שנייה להעביר את התמונה הגדולה? לצורך מה אתה צריך את זה מלכתחילה? איזו בעיה זה פותר?

זה חידה שקיבלתי שבאה בצורה של משחק אבל התשובה שלו בצורה מפושטת למספרים היא צירוף של מה שכתבתי (המספרים מייצגים 4 צבעים אבל לנוחות קוד רשמתי ספרות של 1 עד 4)

תודה!! לא הכרתי את האפשרות הזאת

משעשע, לא הכרתי. השאלה שלי די מדויקת לדעתי (מאוד מקווה…).
רשמתי את כל האפשרויות הקיימות לפיתרון החידה ואני מחפש את הצירוף שפותר אותה רק בצורת מספרים במקום תמונה צבעונית תלת מימדית שלא ניתן להציג כאן כקוד.

אני הייתי עובר על איבר ברשימה לצורך העניין על האיבר הראשון בA
ואז בודק אותו בלולאה ביחס לשאר כאשר העקרון שלי יהיה ל"צבור" את האופציות שכבר נבחרו"
כלומר לנהל רשימה במקביל שכל פעם שיש ערכים חדשים אני מכניס אליה,
כלומר אם הרשימה הראשונה שאני בודק היא

[1, 2, 2, 1]

אז לרשימה שאני מנהל יצברו המספרים 1 ו 2, ברשימה הבאה שאני אבדוק אני אבדוק קודם אם
יש בה אחת מהאיברים האלה, ורק אם לא אבדוק אותה.
וכך הלאה עד שאגיע לצירוף של 4.

מעניין, אנסה. זה לפחות יקצר את הלולאות המטורפות שיצרתי ונתקעות

חשוב שתכניס תנאים של הפסקה כלומר הייתי רץ על זה עם while ולא עם for כאשר יש לי משתנה בוליאני שיודע לעצור כל פעם שאני מגיע לתוצאה רצויה. ובכך אתה לא בודק הכל.

למה לא עשית באמת בעזרת set?

	if len(x) == len(set(x))
?

בניתי משהו אבל אני לא בטוח למה עבור מה שנתת הוא מחזיר שאין פתרון. אולי באג אצלי

import itertools


a = [[3, 3, 3, 2], [2, 1, 3, 4], [1, 3, 4, 3], [3, 3, 2, 3], [3, 2, 3, 3], [2, 3, 3, 3],
[1, 3, 4, 2], [3, 4, 2, 1], [4, 2, 1, 3], [3, 4, 3, 1], [4, 3, 1, 3], [3, 1, 3, 4]]

b = [[3, 3, 1, 4], [1, 1, 3, 2], [1, 4, 2, 3], [3, 1, 4, 3], [1, 4, 3, 3], [4, 3, 3, 1],
[1, 3, 2, 1], [3, 2, 1, 1], [2, 1, 1, 3], [4, 2, 3, 1], [2, 3, 1, 4], [3, 1, 4, 2]]

c = [[1, 3, 4, 4], [3, 2, 4, 2], [1, 2, 4, 2], [3, 4, 4, 1], [4, 4, 1, 3], [4, 1, 3, 4],
[2, 4, 2, 3], [4, 2, 3, 2], [2, 3, 2, 4], [2, 4, 2, 1], [4, 2, 1, 2], [2, 1, 2, 4]]

d = [[3, 2, 2, 1], [1, 2, 4, 1], [1, 3, 4, 2], [2, 2, 1, 3], [2, 1, 3, 2], [1, 3, 2, 2],
[2, 4, 1, 1], [4, 1, 1, 2], [1, 1, 2, 4], [3, 4, 2, 1], [4, 2, 1, 3], [2, 1, 3, 4]]


e = [a, b, c, d]


def is_good_length(iterables):
    for i in range(len(iterables)):
        if len(iterables[i]) != len(iterables[i - 1]):
            return False
        if isinstance(iterables[i][0], list) and not is_good_length(iterables[i]):
            return False
    return True


def get_solution_by_indexes(iterables, possible_indexes):
    items = []
    for iterable, index in zip(iterables, possible_indexes):
        items.append(iterable[index])
    return items


def check_solution(iterables):
    print(iterables)
    for i in zip(*iterables):
        if len(set(i)) != len(i):
            return False
    return True


def solve(iterables):
    indexes_generator = itertools.product(*[list(range(len(iterables[0])))] * len(iterables))
    for possible_indexes in indexes_generator:
        possible_solution = get_solution_by_indexes(iterables, possible_indexes)
        #print(possible_solution)
        if check_solution(possible_solution):
            return possible_solution


assert is_good_length(e)
solve(e)

עבור הקלט הבא שיצרתי כן יש פתרון, והקוד מוצא אותו:

a = [[1, 2, 3, 4], [2, 1, 3, 4], [1, 3, 4, 3], [3, 3, 2, 3], [3, 2, 3, 3], [2, 3, 3, 3],
[1, 3, 4, 2], [3, 4, 2, 1], [4, 2, 1, 3], [3, 4, 3, 1], [4, 3, 1, 3], [3, 1, 3, 4]]

b = [[3, 3, 1, 4], [1, 1, 3, 2], [1, 4, 2, 3], [3, 1, 4, 3], [1, 4, 3, 3], [4, 3, 3, 1],
[1, 3, 2, 1], [2, 3, 4, 1], [2, 1, 1, 3], [4, 2, 3, 1], [2, 3, 1, 4], [3, 1, 4, 2]]

c = [[1, 3, 4, 4], [3, 2, 4, 2], [1, 2, 4, 2], [3, 4, 4, 1], [4, 4, 1, 3], [4, 1, 3, 4],
[2, 4, 2, 3], [4, 2, 3, 2], [3, 4, 1, 2], [2, 4, 2, 1], [4, 2, 1, 2], [2, 1, 2, 4]]

d = [[3, 2, 2, 1], [1, 2, 4, 1], [1, 3, 4, 2], [2, 2, 1, 3], [2, 1, 3, 2], [1, 3, 2, 2],
[2, 4, 1, 1], [4, 1, 1, 2], [1, 1, 2, 4], [3, 4, 2, 1], [4, 1, 2, 3], [2, 1, 3, 4]]

אני מתחיל לחשוד שאין פיתרון לחידה שנתנו לי. גם הקוד שלי לא הניב תשובה וחשבתי שהדרך שלי שגויה.
על הדרך קיוויתי ללמוד דרכים חדשות לפתרון.
תודה רבה על העזרה, עכשיו הולך ללמוד את הדברים שלא מוכרים לי בקוד שלך

תודה רבה לכל העוזרים, כנראה שמשהו השתבש באחת המחרוזות וברגע שתוקנה הקוד מצא את הפיתרון תוך מספר שניות (סהכ 331 אלף צירופים אפשריים ללא סינון כפילויות… קצת כבד למחברת)

האם אתה יכול להעלות לפה את המחרוזות המתוקנות? למקרה שיהיה לי זמן לנסות לכתוב לזה קוד בעצמי

אחרי שכתבתי קוד מסורבל, קיבלתי מידע מלא לחידה.
מדובר בפאזל בשם instant insanity.
יש המון מידע באינטרנט על כל הצירופים האפשריים, גישה נכונה יותר משלי לצימצום האפשרויות ואפילו פרויקט פייתון שעולה בתוצאות הראשונות של גוגל.
ממליץ לך אם כבר לקרוא על המשחק ולחשוב לבד על יצירת רשימה חכמה יותר ממה שכתבתי ולהתאים לה קוד יעיל שלא רץ על אלפי אפשרויות כמו אצלי.
תודה על כל העזרה!