res = <<EOS
5616185650518293 ;2 correct
3847439647293047 ;1 correct
5855462940810587 ;3 correct
9742855507068353 ;3 correct
4296849643607543 ;3 correct
3174248439465858 ;1 correct
4513559094146117 ;2 correct
7890971548908067 ;3 correct
8157356344118483 ;1 correct
2615250744386899 ;2 correct
8690095851526254 ;3 correct
6375711915077050 ;1 correct
6913859173121360 ;1 correct
6442889055042768 ;2 correct
2321386104303845 ;0 correct
2326509471271448 ;2 correct
5251583379644322 ;2 correct
1748270476758276 ;3 correct
4895722652190306 ;1 correct
3041631117224635 ;3 correct
1841236454324589 ;3 correct
2659862637316867 ;2 correct
EOS

aoeuares = <<EOS
90342 ;2 correct
70794 ;0 correct
39458 ;2 correct
34109 ;1 correct
51545 ;2 correct
12531 ;1 correct
EOS

N = res.to_a[0].index(' ')
Tries = res.map { |l| l[0, N].unpack('C*').map { |c| c-0x30 } }
Good  = res.map { |l| l[N+2]-0x30 }

def test_fail(a)
	Tries.zip(Good).find { |try, good|
		match = 0
		N.times { |i| match += 1 if a[i] == try[i] }
		match > good or match+N-a.compact.length < good
	}
end

def bf(a)
	return a if a.compact.length == N
	p = a.index(nil) || a.length
	(0..9).each { |i|
		a[p] = i
		next if test_fail(a)
		resp = bf(a)
		return resp if resp
	}
	a[p] = nil
end

# n = index of Tries we try to guess correct positions
def solve(n=0, a=[])
	if n == Tries.length
		p a
		return bf(a)
	end

	if Good[n] == 0
		aa = solve(n+1, a) if not test_fail(a)
		return aa if aa
	else
	(0...N).each { |p1|
		if a[p1]
			next if a[p1] != Tries[n][p1]
			didp1 = false
		else
			didp1 = true
			a[p1] = Tries[n][p1]
		end
	if Good[n] == 1
		aa = solve(n+1, a) if not test_fail(a)
		return aa if aa
	else
	(p1+1...N).each { |p2|
puts "#{p1} #{p2}" if n == 0
		if a[p2]
			next if a[p2] != Tries[n][p2]
			didp2 = false
		else
			didp2 = true
			a[p2] = Tries[n][p2]
		end
	if Good[n] == 2
		aa = solve(n+1, a) if not test_fail(a)
		return aa if aa
	else
	(p2+1...N).each { |p3|
		if a[p3]
			next if a[p3] != Tries[n][p3]
			didp3 = false
		else
			didp3 = true
			a[p3] = Tries[n][p3]
		end
		aa = solve(n+1, a) if not test_fail(a)
		return aa if aa
		a[p3] = nil if didp3
	} if not test_fail(a)
	end
		a[p2] = nil if didp2
	} if not test_fail(a)
	end
		a[p1] = nil if didp1
	}
	end
	nil
end

res = solve() || abort('no solution')

puts Tries.zip(Good).map { |t, g| "#{t.join} ; #{g}" }, '', res.join, ''
Tries.each { |t| N.times { |p| t[p] = '-' if t[p] != res[p] } }
puts Tries.zip(Good).map { |t, g| "#{t.join} ; #{g}" }