Paradigm — imperative, functional, logic, OO: চিন্তার চার ফ্রেম

চার implementation, একই contract: 4×4 board-এ ৪ queen এমনভাবে যেন কেউ কাউকে attack না করে।

১. Imperative — explicit stack, হাতে backtracking:

def queens_imperative(n=4):
    solutions = []
    board = [-1] * n            # board[r] = চলমান trial column
    row = 0
    while 0 <= row < n:
        found = False
        start = board[row] + 1
        board[row] = -1
        for col in range(start, n):
            ok = True
            for prev in range(row):
                if board[prev] == col or abs(board[prev] - col) == row - prev:
                    ok = False
                    break
            if ok:
                board[row] = col
                found = True
                break
        if found:
            row += 1
        else:
            row -= 1
        if row == n:
            solutions.append(board.copy())
            row -= 1            # শেষ row আবার retry — পরের solution
    return solutions

২. Functional — spec হিসেবে permutation + predicate:

from itertools import permutations

def queens_functional(n=4):
    def safe(cols):
        pairs = ((r, k) for r in range(n) for k in range(n) if r < k)
        return all(abs(cols[r] - cols[k]) not in (0, abs(r - k))
                   for r, k in pairs)
    return [list(p) for p in filter(safe, permutations(range(n)))]

৩. OO — Board নিজের invariant নিজে রক্ষা করে:

class QueensBoard:
    def __init__(self, n=4):
        self._n = n
        self._cols = []                     # private state

    def can_place(self, col):
        r = len(self._cols)
        return all(c != col and abs(c - col) != r - pr
                   for pr, c in enumerate(self._cols))

    def solutions(self):
        out = []
        def walk():
            if len(self._cols) == self._n:
                out.append(list(self._cols))
                return
            for col in range(self._n):
                if self.can_place(col):
                    self._cols.append(col)  # invariant: can_place-এর ভেতরেই
                    walk()                  # বাইরে থেকে state ছোঁয়া অসম্ভব
                    self._cols.pop()
        walk()
        return out

৪. Logic/search — constraints declare, engine solve করে:

def queens_search(n=4):
    def extend(cols):
        if len(cols) == n:
            return [cols]
        return [sol
                for col in range(n)
                if all(c != col and abs(c - col) != len(cols) - r
                       for r, c in enumerate(cols))
                for sol in extend(cols + [col])]
    return extend([])

Runner আর measurement:

import time

IMPLS = {
    "imperative": queens_imperative,
    "functional": queens_functional,
    "oo":         lambda n=4: QueensBoard(n).solutions(),
    "search":     queens_search,
}

for name, fn in IMPLS.items():
    t0 = time.perf_counter()
    reps = 500
    for _ in range(reps):
        result = fn()
    dt = (time.perf_counter() - t0) / reps
    print(f"{name:<11} {len(result)} solutions {dt*1e6:8.1f} µs/run")

print(sorted(map(tuple, IMPLS["functional"]())))
print(sorted(map(tuple, IMPLS["imperative"]())))

Typical output (এই লেখকের মেশিনে; timing আপনারটায় ভিন্ন হবে):

imperative   2 solutions     47.0 µs/run
functional   2 solutions     68.7 µs/run
oo           2 solutions     88.5 µs/run
search       2 solutions     72.6 µs/run
[(1, 3, 0, 2), (2, 0, 3, 1)]
[(1, 3, 0, 2), (2, 0, 3, 1)]

Bug-resistance discussion — আসল ফল:

• Imperative: সবচেয়ে দ্রুত, সবচেয়ে ঝুঁকিতে — board[row] = -1 restore, backtrack-এ start calculation, boundary conditions: তিনটা আলাদা জায়গায় হাতে সিঙ্ক রাখতে হয়। আমার নিজের প্রথম draft-এই backtrack-এ পুরনো column retry ভুল ছিল — এই ফ্রেমে এমন bug স্বাভাবিক।
• Functional: ভুলের জায়গা এক — safe predicate। Spec সঠিক হলে enumeration ভুল হতে পারে না (engine-এর বিশ্বাসযোগ্য)। দাম: সব permutation generate — বড় n-এ অকল্পনীয়।
• OO: invariant (can_place-এর বাইরে placement অসম্ভব) encapsulation-এ বন্দি — ভুল করতে হলে class-এর ভেতরে ঢুকতে হবে। কিন্তু traversal logic তবু হাতে।
• Search/logic: formulation ছোট, generalizes (আজকের build দেখুন) — ভুল হলে সেটা constraint-এর অর্থের ভুল, সহজে unit-testable।

যা প্রমাণিত: ফল identical, কিন্তু bug-এর ঠিকানা paradigm-ভেদে সরে — এটাই paradigm নির্বাচনের প্রকৃত criterion: আপনার সমস্যার কোন দিকটা ভুল-করা সবচেয়ে সহজ, সেই দিকটা কোন ফ্রেম ভাষায় অসম্ভব বানায়?