Interview - Oracle

Question

In a game the only scores which can be made are 2,3,4,5,6,7,8 and they can be made any number of times

What are the total number of combinations in which the team can play and the score of 50 can be achieved by the team.

example 8,8,8,8,8,8,2 is valid 8,8,8,8,8,4,4,2 is also valid. etc...

Answer 1

The problem can be solved with dynamic programming, with 2 parameters:

• i - the index up to which we have considered
• s - the total score.

f(i, s) will contain the total number of ways to achieve score s.

Let score[] be the list of unique positive scores that can be made.

The formulation for the DP solution:

f(0, s) = 1, for all s divisible to score[0]
f(0, s) = 0, otherwise

f(i + 1, s) = Sum [for k = 0 .. floor(s/score[i + 1])] f(i, s - score[i + 1] * k)

Answer 2

This looks like a coin change problem. I wrote some Python code for it a while back.

Edited Solution:

from collections import defaultdict

my_dicto = defaultdict(dict)

def row_analysis(v, my_dicto, coins):
    temp = 0
    for coin in coins:
        if v >= coin:
            if v - coin == 0: # changed from if v - coin in (0, 1):
                temp += 1
                my_dicto[coin][v] = temp
            else:                
                temp += my_dicto[coin][v - coin]
                my_dicto[coin][v] = temp
        else:
            my_dicto[coin][v] = temp
    return my_dicto

def get_combs(coins, value):
    '''
    Returns answer for coin change type problems.
    Coins are assumed to be sorted.

    Example:
        >>> get_combs([1,2,3,5,10,15,20], 50)
        2955
    '''
    dicto = defaultdict(dict)

    for v in xrange(value + 1):
        dicto = row_analysis(v, dicto, coins)

    return dicto[coins[-1]][value]

In your case:

>>> get_combs([2,3,4,5,6,7,8], 50)
3095

Answer 3

It is like visit a 7-branches decision tree.

The code is:

class WinScore{
static final int totalScore=50;
static final int[] list={2,3,4,5,6,7,8};
public static int methodNum=0;

static void visitTree( int achieved , int index){
        if (achieved >= totalScore ){
                return;
        }
        for ( int i=index; i< list.length; i++ ){
                if ( achieved + list[i] == totalScore ) {
                        methodNum++;
                }else if (  achieved + list[i] < totalScore ){
                        visitTree( achieved + list[i], i );
                }
        }
}
public static void main( String[] args ){
        visitTree(0, 0);
        System.out.println("number of methods are:" + methodNum );

}
}
output:
number of methods are:3095

Answer 4

Just stumbled on this question - here's a c# variation which allows you to explore the different combinations:

static class SlotIterator
{
    public static IEnumerable<string> Discover(this int[] set, int maxScore)
    {
        var st = new Stack<Slot>();
        var combinations = 0;
        set = set.OrderBy(c => c).ToArray();
        st.Push(new Slot(0, 0, set.Length));
        while (st.Count > 0)
        {
            var m = st.Pop();
            for (var i = m.Index; i < set.Length; i++)
            {
                if (m.Counter + set[i] < maxScore)
                {
                    st.Push(m.Clone(m.Counter + set[i], i));
                }
                else if (m.Counter + set[i] == maxScore)
                {
                    m.SetSlot(i);
                    yield return m.Slots.PrintSlots(set, ++combinations, maxScore);

                }
            }
        }
    }

    public static string PrintSlots(this int[] slots, int[] set, int numVariation, int maxScore)
    {
        var sb = new StringBuilder();
        var accumulate = 0;
        for (var j = 0; j < slots.Length; j++)
        {
            if (slots[j] <= 0)
            {
                continue;
            }
            var plus = "+";
            for (var k = 0; k < slots[j]; k++)
            {
                accumulate += set[j];
                if (accumulate == maxScore) plus = "";
                sb.AppendFormat("{0}{1}", set[j], plus);
            }
        }

        sb.AppendFormat("={0} - Variation nr. {1}", accumulate, numVariation);
        return sb.ToString();
    }
}
public class Slot
{
    public Slot(int counter, int index, int countSlots)
    {
        this.Slots = new int[countSlots];
        this.Counter = counter;
        this.Index = index;
    }

    public void SetSlot(int index)
    {
        this.Slots[index]++;
    }

    public Slot Clone(int newval, int index)
    {
        var s = new Slot(newval, index, this.Slots.Length);
        this.Slots.CopyTo(s.Slots, 0);
        s.SetSlot(index);
        return s;
    }

    public int[] Slots { get; private set; }

    public int Counter { get; set; }

    public int Index { get; set; }
}

Example:

    static void Main(string[] args)
    {

        using (var sw = new StreamWriter(@"c:\test\comb50.txt"))
        {
            foreach (var s in new[] { 2, 3, 4, 5, 6, 7, 8 }.Discover(50))
            {
                sw.WriteLine(s);
            }
        }
    }

Yields 3095 combinations.