A brute force magic square guesser in Swift, which is not pretty because it's not supposed to be

3x3.swift

import Cocoa

func dupes(nums:[Int])-> Int {
    return nums.count - Set(nums).count
}

func r10k() -> Int {Int.random(in: 1...10000)}

struct Solution {
    let v:[Int]
    let dimension:Int = 3
    var scores:[Int] {
        let r1 = v[0] + v[1] + v[2]
        let r2 = v[3] + v[4] + v[5]
        let r3 = v[6] + v[7] + v[8]
        let c1 = v[0] + v[3] + v[6]
        let c2 = v[1] + v[4] + v[7]
        let c3 = v[2] + v[5] + v[8]
        let d1 = v[0] + v[4] + v[8]
        let d2 = v[2] + v[4] + v[6]
        let sums = [r1,r2,r3,c1,c2,c3,d1,d2]
        var errs = [dupes(nums:v)*1000]
        for i in (0...6) {
            for j in (i+1...7) {
                errs.append(abs(sums[i]-sums[j]))
            }
        }
        return errs
     }
    
    var totalErr:Int {
        scores.reduce(0,+)
    }
    
    func mutate(size:Int = 10)-> Solution {
        var v2 = v.map {$0 + Int.random(in:-size...size)}
        return Solution(v:v2)
    }

}


func random3x3() -> Solution {
    Solution(v:[r10k(),r10k(),r10k(),r10k(),r10k(),r10k(),r10k(),r10k(),r10k()])
}

func aDominatesB(a:Solution,b:Solution) -> Bool {
    let aErr = a.scores.sorted()
    let bErr = b.scores.sorted()
    let ab = zip(aErr, bErr)
    let diffs = ab.map {$0.1 - $0.0}
    return (diffs.min()! >= 0) && (diffs.max()! > 0)
}


var s1 = random3x3()
var variation = 100
for i in 0...100000 {
    let s2 = s1.mutate(size:variation)
    let s1err = s1.totalErr
    variation = s1err/50 + 1
    let s2err = s2.totalErr
    if (s2err <= s1err) {
        s1 = s2
    }
    if i.isMultiple(of: 200) {
        print("\(i): \(s1.v) : \(s1.totalErr)")
        if (s1err == 0) {
            s1 = random3x3() 
            print("\n>> restarting\n")
            print("\(i): \(s1.v) : \(s1.scores) \(s1.scores.max()!);\(s1.totalErr)")
        }
    }
}