Multiple of 3 or 5 in ascending order

Question

I want to get all numbers multiple of 3 or 5 below given number in the fastest way. So I did the below code:

double limit = number / 5;
for (var i = 0; i <= number / 3; i++)
{
    list.Add(i * 3);
    if (i <= limit && ((i * 5) % 3 != 0))
    {
        list.Add(i * 5);
    }
}

But the resulted list will not be sorted in ascending order. If number = 11, list contains

0, 3, 5, 6, 10, 9

instead of

0, 3, 5, 6, 9, 10

To get sorted list, I could use a simple iteration like:

for (var i = 0; i <= number; i++)
{
    if (i % 3 == 0 || i % 5 == 0)
    {
        list.Add(i);
    }
}

But the main purpose of the exercise is to right the fastest algorithm.

Am I missing something in the first algorithm or should I keep the second one?

Answer 1

Here is my implementation although it might not be the fastest in terms of BigO notation.

    static void Main(string[] args)
    {
        int number = 35;
        List<int> list = new List<int>();
        int count3 = 0;
        int count5 = 0;
        int step3 = 3;
        int step5 = 5;
        while (count3 < number || count5<number )
        {
            if ((count3 + step3) <= (count5 + step5))
            {
                count3 += step3;
                if (count3 <= number)
                {
                    list.Add(count3);
                }
            }
            else
            {

                count5 += step5;
                if (count5 <= number)
                {
                    list.Add(count5);
                }
            }

        }
        foreach (var l in list)
        {
            Console.WriteLine(l.ToString());
        }
        Console.ReadLine();

    }

Answer 2

For 3 and 5 there is circular dependence every 15 (3*5=15) that is why we can just do something like this:

static void Main()
{
    int[] deltas= { 3,2,1,3,1,2,3 };

    int number = 30;

    List<int> result = new List<int>();

    int j = 1;
    for(int i = deltas[0]; i<=number; i+=deltas[j++%deltas.Length])
    {
        result.Add(i);
    }

    foreach(int i in result)
        Console.Write(i+", ");
}

Update:

To find circular point we need to calculate Least Common Multiple. Now to find all deltas to that point we just need resolves original problem in less optimal way and subtracts elements from each other.

More generic version:

static void Main()
{
     foreach(int i in multi(30, new []{2,3,4,5,7} ))
        Console.Write(i+", ");
}

static List<int> multi(int max, int[] divs)
{
    int[] deltas = calcDeltas(divs);

    List<int> result = new List<int>();

    int j = 1;
    for(int i = deltas[0]; i<=max; i+=deltas[j++%deltas.Length])
    {
        result.Add(i);
    }

    return result;
}

static int[] calcDeltas(int[] divs)
{
    long max = 1;
    foreach(int div in divs)
        max = lcm(max,div);

    List<long> ret = new List<long>();

    foreach(int div in divs)
    {
        for(int i=div; i<=max; i+=div)
        {
            int idx = ret.BinarySearch(i);
            if (idx < 0)
            {
                ret.Insert(~idx, i);
            }
        }
    }

    for(int i=ret.Count-1; i>0; i--)
        ret[i]-=ret[i-1];

    return ret.ConvertAll(x => (int)x).ToArray();
}

static long gcf(long a, long b)
{
    while (b != 0)
    {
        long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

static long lcm(long a, long b)
{
    return (a / gcf(a, b)) * b;
}

Update 2:

I do some tests for provided solutions (without Eric's solution). I modify some functions to give exact same result (more in description). Tested on i7-3770K@3.5GH.

Username - description
Time 1 - Average time, loops = 100, number = 10000000
Time 2 - Total time, loops = 100000, number = 10000
Time 3 - Total time, loops = 1000000, number = 100
CPU Usage - in percentage

Mrinal Kamboj - with OrderBy as suggested to preserve correct order
434ms, 85447ms, 348600ms, 70%

Mrinal Kamboj - with OrderBy as suggested to preserve correct order, without ToList() instead to materialize query done ForAll(x=>{})
136ms, 51266ms, 273409ms, 80%

Mrinal Kamboj - without AsParallel
154ms, 14559ms, 1985ms, 13%

Mhd - second solution
69ms, 5791ms, 879ms, 13%

ThomW - added condition to prevent duplicates
34ms, 2398ms, 521ms, 13%

Logman - with precalculated deltas for 3,5 as original answer
43ms, 3498ms, 654ms, 13%

Logman - generic solution
47ms, 3529ms, 1270ms, 13%

Logman + HABO - with precalculated deltas for 3,5
37ms, 2655ms, 501ms, 13%

Logman + HABO - generic solution
37ms, 2701ms, 1149ms, 13%

HABO - Unrolled solution (see the comment)
32ms, 2072ms, 464ms, 13%

Test code

Answer 3

I want to get all numbers multiple of 3 or 5 below given number in the fastest way.

Easily done.

private static readonly int [][] lookup = { 
  {}, // 0
  {0}, // 1
  {0}, // 2
  {0}, // 3
  {0, 3}, // 4
  {0, 3}, // 5
  {0, 3, 5}, // 6
  {0, 3, 5, 6}, // 7
  {0, 3, 5, 6}, // 8
  {0, 3, 5, 6}, // 9
  {0, 3, 5, 6, 9}, // 10
  ... and so on; fill out the table as far as you like
};

Now your algorithm is:

static int[] Blah(int x) { return lookup[x]; }

The fastest algorithm is almost always a precomputed lookup table. Solve the problem ahead of time and save the results; your program then just looks up the precomputed result. It does not typically get faster than that; how could it?

Now is it clear that you are not actually looking for the fastest algorithm? What algorithm are you actually looking for?

Answer 4

Looking at the results the values seems to contain a repeating pattern every 14 items, which is probably the key to find the optimal algorithm (short of an extended lookup table)

More optimizations may always be possible (such as precalculating expected size), but the following delivered the expected results and should perform well:

var list=new List<int>(); 
int[] seq = {0,3,5,6,9,10,12,15,18,20,21,24,25,27};
for(int i = 0;;){
    int val = seq[i % 14] + (i++/14) * 30;
    if(val > number)break;
    list.Add(val);
}

(Side note: in general one hard to measure factor is the branch prediction ifs cause, so when doing these puzzles it's always a good idea to get as few as those as possible)