Run Bajtocja - zadanie OIG

Witam, rozwiązuję zadanie Run Bajtocja z OIG http://main.edu.pl/pl/archive/oig/3/run, napisałem taki kod:

 #include <iostream>
using namespace std;

long double t[100000];

int main()
{
	ios::sync_with_stdio(0);
	cout.precision(0);
	cout.setf(ios::fixed);
	long double nww=0;
	long double a,b,c,d,N;
	std::ios::sync_with_stdio(false);
	cin>>N;
	cin>>t[0];
	nww=t[0];
	for(int i=1;i<N;i++)
	{
		cin>>t[i];
		a=nww;
		b=t[i];
		d=a*b;
		while (b!=0)
		{ 
			c = (unsigned long long int)a % (unsigned long long int)b;
			a = b;
			b = c;
		}
		nww=d/a;
	}
	for(int i=0;i<N;i++)
	{
		cout<<nww/t[i]<<endl;
	}
	return 0;
}

Zdobyłem 36 punktów, mam pytanie czy algorytm jest zły czy coś z wielkością zmiennych? Na moim systemie(windows) wyświetla mi liczby z kilkudziesięcioma zerami a na ich serwerze (linux) ten sam kod wyświetla błędne ale mniejsze liczby.

Wywal całkowicie typ double z programu.

Teraz jest jeszcze gorzej bo dostałem 12 punktów, wyniki z serwera to:

• 1 wiersz 1: wczytano '39522063289625506', a oczekiwano '1481615599669266987750572183186476694177987968
• 2 wiersz 1: wczytano '11800033643907337', a oczekiwano '43230800929155840'
• 3 wiersz 1: wczytano '171119132201506', a oczekiwano '8165817953284992'
• 4 wiersz 1: wczytano '43751930418921456', a oczekiwano '2681884324758709209216279280305756091288896418
• 5 wiersz 1: wczytano '64714629344093191', a oczekiwano '27019250580722400'
• 6 wiersz 1: wczytano '3979026467100208', a oczekiwano '16404544995438600'
• 7 wiersz 1: wczytano '59746687835374491', a oczekiwano '5506738520222018540892020640529496152613634454
• 8 wiersz 1: wczytano '114841261743338477', a oczekiwano '114831814968070200'
• 9 wiersz 1: wczytano '17147839315031388', a oczekiwano '5548456236284306560141202615078962032557677140
• 10 wiersz 1: wczytano '9959784218468949', a oczekiwano '22966362993614040'
• 11 wiersz 1: wczytano '5912695661656370', a oczekiwano '19122616793460273262105450266068485334141341579
• 12 wiersz 1: wczytano '10108238073237339', a oczekiwano '2534242986814977390791137526610460167119769489
• 13 wiersz 1: wczytano '10116318683494691', a oczekiwano '3355163348001095149031954757088089128389537709
• 14 wiersz 1: wczytano '28712251851393720', a oczekiwano '2362568461901704728834318532872332220314881879
• 15 wiersz 1: wczytano '151349981384922028', a oczekiwano '244132074396509488646212915063474329432537794

To zdecydowanie za duże wartości nawet jak na unsigned long long int.

czyli w grę wchodzi tylko własna arytmetyka??

Zdecydowanie tak.
Aczkolwiek możesz zdecydowanie zmniejszyć użycie własnej arytmetyki:

1. Tablice możesz wczytać nawet jako zwykłe unsigned short
2. Tworzysz sito Eratostenes rozmiarem maksymalnej liczby z tablicy lub od razu tak:

  static struct { unsigned short prime,add; unsigned count; } P[]=
    { 
     {  2},   {  3},   {  5},   {  7},   { 11},   { 13},   { 17},   { 19},   { 23},   { 29}, 
     { 31},   { 37},   { 41},   { 43},   { 47},   { 53},   { 59},   { 61},   { 67},   { 71}, 
     { 73},   { 79},   { 83},   { 89},   { 97},   {101},   {103},   {107},   {109},   {113}, 
     {127},   {131},   {137},   {139},   {149},   {151},   {157},   {163},   {167},   {173},
     {179},   {181},   {191},   {193},   {197},   {199},   {211},   {223},   {227},   {229},
     {233},   {239},   {241},   {251},   {257},   {263},   {269},   {271},   {277},   {281},
     {283},   {293},   {307},   {311},   {313},   {317},   {331},   {337},   {347},   {349},
     {353},   {359},   {367},   {373},   {379},   {383},   {389},   {397},   {401},   {409},
     {419},   {421},   {431},   {433},   {439},   {443},   {449},   {457},   {461},   {463},
     {467},   {479},   {487},   {491},   {499},
    };
   const unsigned cnt=sizeof(P)/sizeof(*P);

3. Każdą z liczb dzielisz na liczby pierwsze i zliczasz w add np: 12 -> dwie dwójki oraz jedna trójka.
4. Po podziale każdej liczby w count wpisujesz max z counti add
5. Po przejściu wszystkich liczb przeglądasz tablicę jeszcze raz, każdą liczbę znowu rozkładasz do add
6. I wypisujesz Iloczyn P[i].prime^{(P[i].count-P[i].add)} tylko do obliczenia tego iloczynu potrzebujesz własną arytmetykę.