Summer Challenge #1

[icymint3]

summer is almost done and we have not had a challenge, so here goes the first one for whoever is not busy enough:

sum all the numbers divisible by 3 and 5 less than an integer limit (say 1000).
most efficient code wins. its open do it in whatever language you like (js,php... even Java)

implement like

#include <iostream>

/*function return the sum of all numbers n | [0,limit) and n is a multiple of 3 or 5 or both*/
unsigned int ChallengeSolution(unsigned int limit)
{
...
}

int main()
{
    unsigned int limit;

    cin >> limit;

    cout << ChallengeSolution(limit);

    return 0;
}

[leoandru]

Well the simplest solution I could think of without brain stroming this too hard. But you did say the most efficient so I did it with D inline assembly..

Note: the argument and return values are in the EAX register.

public extern(D) uint ChallengeSolution(uint limit)
{
	asm
	{
		naked;
		mov ECX, EAX;
		xor EAX, EAX;
		xor EDX, EDX;
	     X0:
		add EDX, 15;
		cmp EDX, ECX;
		ja X1;
		add EAX, EDX;
		jmp X0;
	     X1:
		ret;
	}
}

I just made the assumption that all multiples of 15 are divisible by 3 and 5, so I just sum those up until I reach the limit. If that's wrong let me know.

[crosswire]

Mi tell you... as mi ready fi open mi compiler inna C#... I scrolled to post 2 and see the answer already. Granted my solution never included 15 in it, but I can't even dust of the compiler in C# no less.

[Utech22]

Who else taking the challenge with a different language?

[icymint3]

well i havent downloaded the D language tools yet, so you have to run it and tell us your result. but for starts let us say the limit was 19.
the answer would be 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 = 78

public extern(D) uint ChallengeSolution(uint limit)
{
	asm
	{
		naked;
		mov ECX, EAX; // store the limit which was in EAX somewhere else
		xor EAX, EAX;  // set EAX to 0
		xor EDX, EDX;  // set EDX to 0
	     X0:                        // mark where loop should start
		add EDX, 15;   // set EDX+= 15
		cmp EDX, ECX;// some flag = EDX  limit
		ja X1;            // if we can end then break out of the loop
		add EAX, EDX;// set EAX+= EDX
		jmp X0;         // goto the start of the loop
	     X1:
		ret;
	}
}

is that equivalent? i dont think it right still.

[icymint3]

hint : it can be done without looping ... its second form math.

its a series, called an Arithmetic Progression, you might need to use some Set Theory to get the correct answer though.

xwire post the code, Utech22 show us what U.T.E.C.H teach you (been ther done that, i wont give them credit for what you do, even though yu dun sign off pon di document already).

[Artificial_Intelligence]

#include <iostream.h>
  int rs=0,result=0;
  int num=0;
  int divby3(int aNum){rs=aNum+1;   if(rs<=1000&&rs%3==0&&rs%5==0){result+=rs; divby3(rs);}
  else{if(rs>=1000){return result;}else{divby3(rs);}}}

int main(int argc, char* argv[])
{

   cout<<divby3(0);

	return 0;
}
//---------------------------------------------------------------------------

not sure its a winner but, ,,,,,,cool

some recursion

[aonekilla]

well i havent downloaded the D language tools yet, so you have to run it and tell us your result. but for starts let us say the limit was 19.
the answer would be 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 = 78

ok,
i think you should have said numbers divisible by 3 or 5 and not 3 and 5...

[aonekilla]

Here is my solution

#include <iostream.h>

unsigned int ChallengeSolution(unsigned int limit)
{
	if(limit < 3)return 0;

	if(((limit%5)==0) || ((limit%3)==0)){
		return limit + ChallengeSolution(limit-1);}
	else{
		return ChallengeSolution(limit-1);}
}

int main()
{
    unsigned int limit;
    cin >> limit;
    cout << ChallengeSolution(limit) << endl;
    return 0;
}

[icymint3]

ok,
i think you should have said numbers divisible by 3 or 5 and not 3 and 5...

you are right, sorry.

the recursion thing, is it because i said it can be done without loops? recursion is normally less efficient than looping for procedural(imperative) languages, what i meant was it can be solved without any type of repetitive construct (including looping, jumping and recursion).

anyway better you ignore the hint and give me your best solution, hands down.

the A.P. : for first term a, and difference d
we can find each term T(n) by :
T(n) = a + (n-1) * d
and its summation by :
S(a,d) = n / 2 ( 2 * a + ( n - 1 ) * d )
or
S(a,d) = n / 2 ( a + l ) ... where l is the last term in the sequence.

if we know the term n (or number of terms for the summation)

the two series to be used in finding the sum are :
a = 0, d = 3 ... i.
and a = 0, d = 5 ... ii.