פותר את רוב הסודוקואים הקיימים (אא"כ זה ברמת קושי מטורפת) בהצלחה! סודוקו.xlsm

@big אמר בשיתוף | קובץ אקסל פותר סודוקו !:

@פייתוניסט אתה כתבת את זה?

כן.

פותר-סודוקו.xlsm יותר מהיר. יותר מדויק. יותר נוח. וללא באגים.
מעוצב יותר יפה מהגירסה הקודמת.

צילום מסך

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

בניתי שתי פונקציות גימטריה לאקסל 1) פונקצייה הממירה ממספרי לאותיות לדוגמא 253 = רנג 2) פונקציה המחזירה את הגימטריה של טקסט מסוים לדוג' פייתוניסט = 635. בבקשה:
פונקציה 1

Function NUM_TO_TXT(X)
    G = ""
    TV = Int(X / 400)
    For I = 1 To TV
        G = G & "ת"
    Next I
    X = X - (TV * 400)
    TV = Int(X / 300)
    For I = 1 To TV
        G = G & "ש"
    Next I
    X = X - (TV * 300)
    TV = Int(X / 200)
    For I = 1 To TV
        G = G & "ר"
    Next I
    X = X - (TV * 200)
    TV = Int(X / 100)
    For I = 1 To TV
        G = G & "ק"
    Next I
    X = X - (TV * 100)
    TV = Int(X / 90)
    For I = 1 To TV
        G = G & "צ"
    Next I
    X = X - (TV * 90)
    TV = Int(X / 80)
    For I = 1 To TV
        G = G & "פ"
    Next I
    X = X - (TV * 80)
    TV = Int(X / 70)
    For I = 1 To TV
        G = G & "ע"
    Next I
    X = X - (TV * 70)
    TV = Int(X / 60)
    For I = 1 To TV
        G = G & "ס"
    Next I
    X = X - (TV * 60)
    TV = Int(X / 50)
    For I = 1 To TV
        G = G & "נ"
    Next I
    X = X - (TV * 50)
    TV = Int(X / 40)
    For I = 1 To TV
        G = G & "מ"
    Next I
    X = X - (TV * 40)
    TV = Int(X / 30)
    For I = 1 To TV
        G = G & "ל"
    Next I
    X = X - (TV * 30)
    TV = Int(X / 20)
    For I = 1 To TV
        G = G & "כ"
    Next I
    X = X - (TV * 20)
    TV = Int(X / 10)
    For I = 1 To TV
        G = G & "י"
    Next I
    X = X - (TV * 10)
    TV = Int(X / 9)
    For I = 1 To TV
        G = G & "ט"
    Next I
    X = X - (TV * 9)
    TV = Int(X / 8)
    For I = 1 To TV
        G = G & "ח"
    Next I
    X = X - (TV * 8)
    TV = Int(X / 7)
    For I = 1 To TV
        G = G & "ז"
    Next I
    X = X - (TV * 7)
    TV = Int(X / 6)
    For I = 1 To TV
        G = G & "ו"
    Next I
    X = X - (TV * 6)
    TV = Int(X / 5)
    For I = 1 To TV
        G = G & "ה"
    Next I
    X = X - (TV * 5)
    TV = Int(X / 4)
    For I = 1 To TV
        G = G & "ד"
    Next I
    X = X - (TV * 4)
    TV = Int(X / 3)
    For I = 1 To TV
        G = G & "ג"
    Next I
    X = X - (TV * 3)
    TV = Int(X / 2)
    For I = 1 To TV
        G = G & "ב"
    Next I
    X = X - (TV * 2)
    TV = Int(X / 1)
    For I = 1 To TV
        G = G & "א"
    Next I
    X = X - (TV * 1)
    NUM_TO_TXT = G
End Function

פונקציה 2

Function TXT_TO_NUM(X)
    XLEN = Len(X)
    G = 0
    For I = 1 To XLEN
        XText = Mid(X, I, 1)
        Select Case XText
            Case "א"
                G = G + 1
            Case "ב"
                G = G + 2
            Case "ג"
                G = G + 3
            Case "ד"
                G = G + 4
            Case "ה"
                G = G + 5
            Case "ו"
                G = G + 6
            Case "ז"
                G = G + 7
            Case "ח"
                G = G + 8
            Case "ט"
                G = G + 9
            Case "י"
                G = G + 10
            Case "כ", "ך"
                G = G + 20
            Case "ל"
                G = G + 30
            Case "מ", "ם"
                G = G + 40
            Case "נ", "ן"
                G = G + 50
            Case "ס"
                G = G + 60
            Case "ע"
                G = G + 70
            Case "פ", "ף"
                G = G + 80
            Case "צ", "ץ"
                G = G + 90
            Case "ק"
                G = G + 100
            Case "ר"
                G = G + 200
            Case "ש"
                G = G + 300
            Case "ת"
                G = G + 400
        End Select
    Next
    TXT_TO_NUM = G
End Function

יש ללחוץ באקסל ALT + F11 להוסיף מודול להדביק את הקוד ולשמור וזהו יש לכם את הפונקציה החדשה באקסל
בהצלחה

פונקצית גימטריא בפייתון לתועלת המתכנתים החובבים והלומדים:

def gim(text):
    g = 0
    # רשימת האותיות
    mylist = ["א","ב","ג","ד","ה","ו","ז","ח","ט","י","כ","ל","מ","נ","ס","ע","פ","צ","ק","ר","ש","ת"]
    # רשימת הערכים
    dolist = [x for x in range(1,11)] + [x * 10 for x in range(2,11)] + [x * 100 for x in range(2,5)]
    # המרה למילון
    mil = dict(zip(mylist,dolist))
    # ספירת האותיות והוספה למשתנה את ערכם כפול מספר המופעים שלהם אות אחר אות
    for i in mylist:
        g += text.count(i) * mil[i]
    # התהליך הקודם על האותיות הסופיות
    mylist = ["ך","ם","ן","ף","ץ"]
    dolist = [20,40,50,80,90]
    mil = zip(mylist,dolist)
    mil = dict(mil)
    for i in mylist:
        g += text.count(i) * mil[i]
    # מחזיר את הערך הסופי
    return g

מצאתם טעות? שיפור? משהו לא מובן? כתבו!

לאור האובססיה שלי לסודוקו ......... ביקשתי מ GPT 4 קוד פייתון פותר סודוקו והתוצאה מהירה ומדהימה:

Spoiler

pip install numpy

import numpy as np

def is_valid(board, row, col, num):
    if num in board[row]:
        return False
    if num in board[:, col]:
        return False

    square_row = (row // 3) * 3
    square_col = (col // 3) * 3
    if num in board[square_row:square_row + 3, square_col:square_col + 3]:
        return False
    return True

def solve_sudoku(board):
    for row in range(9):
        for col in range(9):
            if board[row, col] == 0:
                for num in range(1, 10):
                    if is_valid(board, row, col, num):
                        board[row, col] = num
                        if solve_sudoku(board):
                            return True
                        board[row, col] = 0
                return False
    return True

def print_board(board):
    for row in range(9):
        if row % 3 == 0 and row != 0:
            print("- - - - - - - - - - -")
        for col in range(9):
            if col % 3 == 0 and col != 0:
                print("| ", end="")
            print(board[row, col], end=" ")
        print()

def main():
    board = np.array([
        [5, 3, 0, 0, 7, 0, 0, 0, 0],
        [6, 0, 0, 1, 9, 5, 0, 0, 0],
        [0, 9, 8, 0, 0, 0, 0, 6, 0],
        [8, 0, 0, 0, 6, 0, 0, 0, 3],
        [4, 0, 0, 8, 0, 3, 0, 0, 1],
        [7, 0, 0, 0, 2, 0, 0, 0, 6],
        [0, 6, 0, 0, 0, 0, 2, 8, 0],
        [0, 0, 0, 4, 1, 9, 0, 0, 5],
        [0, 0, 0, 0, 8, 0, 0, 7, 9]
    ])

    print("Unsolved Sudoku:")
    print_board(board)

    if solve_sudoku(board):
        print("\nSolved Sudoku:")
        print_board(board)
    else:
        print("\nThis sudoku cannot be solved.")

if __name__ == "__main__":
    main()

עשיתי כמה שינויים סודוקו.xlsm

@ישעיהו-כץ Notepad++

@תודה-רבה-4 יותר פשוט בתחילת המאקרו:

for i = 1 to **

ובסוף המאקרו:

next i

ובמקום הכוכביות לכתוב כמה פעמים שיחזור.

@פשוט-שבפשוט תוסיף בסוף הקובץ את הפקודה () input ותריץ שוב

@תודה-רבה-4 אהה. אבל אני גם לא רע בVBS אולי אפילו יותר מפייתון. אגב רוב הפוסטים שלי דווקא על מאקרו וVBS

@יחיאל-האלוף רק ביקורת אחת על השם של הנושא

לנוחות הציבור מצורף קובץ עם שתי הפונקציות גימטריא.xlsm

@avraham-s אולי תפרט קצת יותר מה אתה רוצה לעשות (אם עמודה A מופיעה בעמודה G למה צריך להשוות פה משהו )

@avraham-s
=[חוברת1.xlsx]גיליון1!$C$9
אתה מתכוון לזה? (אפשר להכניס את זה בכל נוסחה שהיא, (לא בדיוק הבנתי למה אתה מתכוון))

@צדיק-תמים אדרבה, הבעיה היא שאני לא יודע אנגלית

@סקרן-0 אמר בשיתוף | קובץ אקסל פותר סודוקו !:

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

בדיוק! קליטה מהירה!

@מאן-דאמר-5 אולי?

start = datetime.now()
while True:
     print ( datetime.now() - start )

@שמעלקא-0
א. האופציה של הצגת הקוד בפורום לא יעילה במקרה שיש לך גם טפסים. הצורה הפשוטה ביותר היא העלאת קובץ וורד מוכן עם כל המאקרו
ב. הערך הכלכלי תלוי כמובן ברמת המקצועיות והשכלול של המאקרו. אם תעשה מזה תוסף רציני ונוח אם הרבה פונקציות אז יש מה לדבר על כסף אבל אם זה פקודה בודדת לא נראה לי שיצא מזה משהו (חוץ מלייקים בפורום )
בהצלחה.

@צדיק-וטוב-לו-0 אמר בשיתוף | קובץ אקסל פותר סודוקו !:

@שלום-עולם הוא יכול לפתור רק אם יש הכרח, כלומר רק אופציה אחת של פיתרון.

יפה מאוד! אחזת את זה!