Zitat von Renga   Zitat von Renga Ach jungs, jetzt dachte ich, ich komme heim und ihr habt das geloest. Nur so viel zur Loesung: Traue niemals der clone() Methode....

type Cell =
    | Assigned of char
    | Undecided of char list

let assign row col newValue board =
    let at r c = r * 9 + c
    let affectedIndices =
        let sameRow = [for c in 0 .. 8 -> at row c]
        let sameColumn = [for r in 0 .. 8 -> at r col]
        let sameSector =
            [for r in 0 .. 2 do
                for c in 0 .. 2 ->
                    at (row - row % 3 + r) (col - col % 3 + c)]
        List.concat [sameRow; sameColumn; sameSector] |> Set.ofList

    // Update target cell and affected cells
    List.mapi (fun index cell ->
        match (index, cell) with
            | (index, _) when index = at row col -> Assigned newValue
            | (index, Undecided xs) when affectedIndices.Contains index ->
                Undecided (List.filter ((<>) newValue) xs)
            | (_, cell) -> cell) board

let rec solve board =
    if List.exists ((=) (Undecided [])) board then None     // Invalid solution
    elif List.forall (function
        | Assigned _ -> true
        | _ -> false) board then Some board                 // Complete solution
    else
        // Find first uncompleted cell and its row/col
        let cell = List.find (function
            | Undecided _ -> true
            | _ -> false) board
        let row, col =
            let index = List.findIndex ((=) cell) board
            (index / 9, index % 9)

        // Extract the remaining choices
        let remainingChoices = (function
            | Undecided xs -> xs
            | _            -> failwith "Invalid board") cell

        // Return the first valid solution, if one exists
        List.tryPick (fun c ->
            let board' = assign row col c board
            solve board') remainingChoices


let emptyBoard = [for _ in 1 .. 81 -> Undecided ['1' .. '9']]
let puzzle = emptyBoard |> assign 0 2 '9'
                        |> assign 0 3 '6'
                        |> assign 0 5 '7'
                        |> assign 0 6 '4'
                        |> assign 0 7 '3'
                        |> assign 0 8 '1'
                        |> assign 1 0 '8'
                        |> assign 1 4 '5'
                        |> assign 1 5 '3'
                        |> assign 1 8 '9'
                        |> assign 2 1 '6'
                        |> assign 2 3 '2'
                        |> assign 2 6 '5'
let solution = solve puzzle

Zitat von Renga   Zitat von igor]2 ... was ist das? F#? bei mir sinds in java ein paar Zeilen mehr geworden.

type Cell =
    | Assigned of char
    | Undecided of char list

let assign row col value board =
    let at r c = r * 9 + c
    let affected = Set.ofSeq (seq {
        for i in 0 .. 8 do
            yield at row i                  // Same row
            yield at i col                  // Same column
        for r in 0 .. 2 do                  // Same sector
            for c in 0 .. 2 do
                yield at (row - row % 3 + r) (col - col % 3 + c) })
    List.mapi (fun i cell ->
        match (i, cell) with
            | (i, _) when i = at row col -> Assigned value
            | (i, Undecided xs) when affected.Contains i ->
                Undecided (List.filter ((<>) value) xs)
            | (_, cell) -> cell) board

let rec solve board =
    let remainingIndicesAndCells =
        (List.zip [0 .. 80] board) |>
            List.filter (function
                | (_, Undecided _) -> true
                | _ -> false)
    match remainingIndicesAndCells with
        | [] -> Some board                  // Solved
        | (_, Undecided []) :: _ -> None    // Impossible to solve
        | (i, Undecided xs) :: _ ->
            List.tryPick (fun c ->
                solve (assign (i / 9) (i % 9) c board)) xs
        | _ -> failwith "Invalid case"      // To shut up compiler



let emptyBoard = [for _ in 1 .. 81 -> Undecided ['1' .. '9']]
let puzzle = emptyBoard |> assign 0 2 '9'
                        |> assign ...

let solution = solve puzzle