using System;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        int[] ans = Scale.Permutate(new int[] { 44, 10, 50, 11, 30, 20, 22, 33 });

​

        for (int i = 0; i < 36; i++)

            if (ans[i] != 0)

                Console.WriteLine("{0} {1}", i, ans[i]);

        Console.WriteLine("Average weighings: {0}", ((double)Enumerable.Range(0, 36).Select(i => i * ans[i]).Sum()) / ans.Sum());

    }

}

​

public class Scale

{

    private int valuesum;

    private int[] value;

    private int[] marks;

    private List<int> tests;//list of combinations that have been checked

​

    private static int[] bit = { 1, 2, 4, 8, 16, 32, 64, 128 };//look up table for powers of 2

​

    public Scale(int[] weights)

    {

        valuesum = weights.Sum();

        value = weights;

    }

​

    public int Solve(bool show)

    {

        int iteration = 1;

        int total;

        int totalmarks;

        int test;

        string weights;

​

        marks = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 };

        tests = new List<int>();

​

        if (show)

            Console.WriteLine("Weights: A={0}, B={1}, C={2}, D={3}, E={4}, F={5}, G={6}, H={7}", value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7]);

​

        do

        {

            test = GetNextTest();

​

            weights = string.Empty;

            total = 0;

            totalmarks = 0;

​

            for (int i = 0; i < 8; i++)

                if ((bit[i] & test) != 0)

                {

                    weights += (char)('A' + i);

                    total += value[i];

                    totalmarks += marks[i];

                }

​

            if (show)

                Console.WriteLine("{0} [{1}] {2} {3} {4} {5} {6}", iteration, string.Join(", ", marks), weights, total, valuesum - total, totalmarks, marks.Sum() - totalmarks);

​

            if (total * 2 == valuesum)

                break;

            else if (total * 2 > valuesum)

            {

                for (int i = 0; i < 8; i++)

                    if ((bit[i] & test) != 0)

                        marks[i]++;

            }

            else

                for (int i = 0; i < 8; i++)

                    if ((bit[i] & test) == 0)

                        marks[i]++;

​

            iteration++;

            tests.Add(test);

​

        } while (true);

​

        return iteration;

    }

​

    private int GetNextTest()

    {

        List<int[]> marble = new List<int[]>();

        int[] index = new int[4];

        int test, difference, besttest = 0, bestdifference = int.MaxValue;

​

        for (int i = 0; i < 8; i++)

            marble.Add(new int[] { i, marks[i] });

​

        marble.Sort((i, j) => i[1] - j[1]);

        int target = marks.Sum() / 2;

​

        for (index[0] = 0; index[0] < 5; index[0]++)

            for (index[1] = 7; index[1] > index[0] + 2; index[1]--)

                for (index[2] = index[1] - 1; index[2] > index[0] + 1; index[2]--)

                    for (index[3] = index[0] + 1; index[3] < index[2]; index[3]++)

                    {

                        test = index.Select(i => bit[marble[i][0]]).Sum();

                        if ((test & 1) == 0)

                            test ^= 0xFF;

                        if (tests.Contains(test))

                            continue;

                        difference = Math.Abs(index.Select(i => marble[i][1]).Sum() - target);

                        if (difference == 0)

                            return test;

                        else if (difference < bestdifference)

                        {

                            bestdifference = difference;

                            besttest = test;

                        }

                    }

​

        return besttest;

    }

​

    public static int[] Permutate(int[] weights)

    {

        int tries;

        int[] ans = new int[36];

        Scale tester;

​

        for (int a = 0; a < 8; a++)

        {

            for (int b = 0; b < 8; b++)

            {

                if (a == b)

                    continue;

                for (int c = 0; c < 8; c++)

                {

                    if (a == c || b == c)

                        continue;

                    for (int d = 0; d < 8; d++)

                    {

                        if (a == d || b == d || c == d)

                            continue;

                        for (int e = 0; e < 8; e++)

                        {

                            if (a == e || b == e || c == e || d == e)

                                continue;

                            for (int f = 0; f < 8; f++)

                            {

                                if (a == f || b == f || c == f || d == f || e == f)

                                    continue;

                                for (int g = 0; g < 8; g++)

                                {

                                    if (a == g || b == g || c == g || d == g || e == g || f == g)

                                        continue;

                                    for (int h = 0; h < 8; h++)

                                    {

                                        if (a == h || b == h || c == h || d == h || e == h || f == h || g == h)

                                            continue;

                                        tester = new Scale(new int[] { weights[a], weights[b], weights[c], weights[d], weights[e], weights[f], weights[g], weights[h] });

                                        tries = tester.Solve(false);

                                        ans[tries]++;

                                        if (tries >= 28)

                                            tester.Solve(true);

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

​

        return ans;

    }

}