An optimization challenge with strange coins
Score = 26/14 ~= 1.857
import java.util.*;
public class LembikWeighingOptimisation {
public static void main(String[] args) {
float best = 0;
int opt = 1;
for (int n = 6; n < 32; n+=2) {
long start = System.nanoTime();
System.out.format("%d\t", n);
opt = optimise(n, n / 2 + 1);
float score = n / (float)opt;
System.out.format("%d\t%f", opt, score);
if (score > best) {
best = score;
System.out.print('*');
}
System.out.format(" in %d seconds", (System.nanoTime() - start) / 1000000000);
System.out.println();
}
}
private static int optimise(int numCoins, int minN) {
MaskRange.N = numCoins;
Set<MaskRange> coinSets = new HashSet<MaskRange>();
coinSets.add(new MaskRange(0, 0));
int allCoins = (1 << numCoins) - 1;
for (int n = minN; n < numCoins; n++) {
for (int startCoins = 1; startCoins * 2 <= numCoins; startCoins++) {
for (int mask = (1 << startCoins) - 1; mask < (1 << numCoins); ) {
// Quick-reject: in n turns, do we cover the entire set?
int qr = (1 << (n-1)) - 1;
for (int j = 0; j < n; j++) qr |= mask << j;
if ((qr & allCoins) == allCoins && canDistinguishInNTurns(mask, coinSets, n)) {
System.out.print("[" + Integer.toBinaryString(mask) + "] ");
return n;
}
// Gosper's hack to update
int c = mask & -mask;
int r = mask + c;
mask = (((r^mask) >>> 2) / c) | r;
}
}
}
return numCoins;
}
private static boolean canDistinguishInNTurns(int mask, Set<MaskRange> coinsets, int n) {
if (n < 0) throw new IllegalArgumentException("n");
int count = 0;
for (MaskRange mr : coinsets) count += mr.size();
if (count <= 1) return true;
if (n == 0) return false;
// Partition.
Set<MaskRange>[] p = new Set[Integer.bitCount(mask) + 1];
for (int i = 0; i < p.length; i++) p[i] = new HashSet<MaskRange>();
for (MaskRange range : coinsets) range.partition(mask, p);
for (int d = 0; d < 2; d++) {
boolean ok = true;
for (Set<MaskRange> s : p) {
if (!canDistinguishInNTurns((mask << 1) + d, s, n - 1)) {
ok = false;
break;
}
}
if (ok) return true;
}
return false;
}
static class MaskRange {
public static int N;
public final int mask, value;
public MaskRange(int mask, int value) {
this.mask = mask;
this.value = value & mask;
if (this.value != value) throw new IllegalArgumentException();
}
public int size() {
return 1 << (N - Integer.bitCount(mask));
}
public void partition(int otherMask, Set<MaskRange>[] p) {
otherMask &= (1 << N) - 1;
int baseline = Integer.bitCount(value & otherMask);
int variables = otherMask & ~mask;
int union = mask | otherMask;
partitionInner(value, union, variables, baseline, p);
}
private static void partitionInner(int v, int m, int var, int baseline, Set<MaskRange>[] p) {
if (var == 0) {
p[baseline].add(new MaskRange(m, v));
}
else {
int lowest = var & (1 + ~var);
partitionInner(v, m, var & ~lowest, baseline, p);
partitionInner(v | lowest, m, var & ~lowest, baseline + 1, p);
}
}
@Override
public String toString() {
return String.format("(x & %x = %x)", mask, value);
}
}
}
Save as LembikWeighingOptimisation.java, compile as javac LembikWeighingOptimisation.java, run as java LembikWeighingOptimisation.
Many thanks to Mitch Schwartz for pointing out a bug in the first version of the quick-reject.
This uses some fairly basic techniques which I can't rigorously justify. It brute-forces, but only for starting weighing operations which use at most half of the coins: sequences which use more than half of the coins aren't directly transferable to the complementary weighings (because we don't know the total weight), but on a hand-wavy level there should be about the same amount of information. It also iterates through starting weighings in order of the number of coins involved, on the basis that that way it covers dispersed weighings (which hopefully give information about the top end relatively early) without first crawling through a bunch which start with a dense subset at the bottom end.
The MaskRange class is a massive improvement on the earlier version in terms of memory usage, and removes GC from being a bottleneck.
20 [11101001010] 11 1.818182* in 5364 seconds
22 [110110101000] 12 1.833333* in 33116 seconds
24 [1000011001001] 13 1.846154* in 12181 seconds
26 [100101001100000] 14 1.857143* in 73890 seconds
Python 2, score = 1.0
This is the easy score, in case nobody finds a better score (doubtful). n weighings for each n.
import antigravity
import random
def weigh(coins, indices):
return sum(coins[i] for i in indices)
def main(n):
coins = [random.choice([-1,1]) for i in range(n)]
for i in range(len(coins)):
print weigh(coins, [i]),
main(4)
I imported antigravity so the program can work with negative weights.
C++, Score 23/12 25/13 27/14 28/14 = 2 31/15
The solutions of Matrix property X revisited (or the Joy of X) are directly usable as solutions to this problem. E.g. the solution of 31 rows 15 columns:
1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 0
1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1
1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1
1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0
1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1
0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1
0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1
1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1
0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0
0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0
0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0
1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1
0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0
0 0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0
1 0 0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1
row N represent which coins you put on the scale for measurement N. Whatever the results of the weighting you get, there is obviously some set of coin values that gives that weight. If there is another combination too (the solution is not unique) consider how they differ. You must replace a set of coins weighting 1 by coins weighting -1. This gives a set of columns that correspond to that flip. There is also set of coins weighting -1 that you replace by 1. That is another set of columns. Because the measurements do not change between the two solutions that means the column sums of the two sets must be the same. But the solutions to Matrix property X revisited (or the Joy of X) are exactly these matrices where such column sets do not exist, so there are no duplicates and each solution is unique.
Each actual set of measurements can be described by some 0/1 matrix. But even if some column sets sum to the same vectors it could be that signs of the candidate solution coin values do not exactly correspond to such a set. So I don't know if matrices such as the one above are optimal. But at least they provide a lower bound. So the possibility that 31 coins can be done in less that 15 measurements is still open.
Notice that this is only true for a non fixed strategy where your decision to put coin 0 on the scales depends on the result of the previous weightings. Otherwise you will have solutions where the signs of the coins correspond with the sets that have the same column sum.