ich habe n Zahlen! und wie den "kleinesten" gemeinsamen Teiler rausfinden, wobei es auc hder größe sein köntne weis nich genau:)

Bsp:

4 Zahlen

3, 4 , 7, 6

und will ich den kleinsten gemeinsamen Teiler bzw. den größten.. Gibts nen Alogirhtirums!

int kgt ()
{
   return 1;
}

int ggt (int x, int y)
{
   // normaler ggt halt
}

int ggt (std::vector<int> const & numbers)
{
   assert (numbers.size() >= 2);

   int result = ggt (numbers[0], numbers[1]);

   for (std::vector<int>::const_iterator it=numbers.begin()+2; it!=numbers.end(); ++it) {
      result = ggt(result, *it);
   }
   return result;
}

Aber suchst du vielleicht auch das kleinste gemeinsame Vielfache?

Ich will haben:

Bsp.:

8,3 = 24

3,2,1,3 = 6

kgv(8,3) // 24
kgv(3,kgv(2, kgv(1, 3))) // 6

kannst auch meinen interativen Code wieder verwendnen. Musst nur ggt durch kgv ersetzten.

Für zwei Opeanden findest du auch was in boost:

ggt: boost::math::gcd
kgv: boost::math::lcm

(<boost/math/common_factor_rt.hpp>)

int kgv (std::vector<int> const & numbers) 
{ 
   assert (numbers.size() >= 2); 

   int result = boost::math::lcm(numbers[0], numbers[1]); 

   for (std::vector<int>::const_iterator it=numbers.begin()+2; it!=numbers.end(); ++it) { 
      result = boost::math::lcm(result, *it); 
   } 
   return result; 
}

p = zeiger auf die zahlen!!

bool Teilbar(int Value,int *p){

	for(int i=0; i< 4; i++){
		if(Value%p[i]!=0)
			return false;
	}
	return true;
}

int divisor(int Value,int *p){

	int iMin = Value;

	int iDivisor=1;
	while(1){	

		if(Teilbar(iMin,p)){
			if(iMin%iDivisor)
				return iMin;
			iMin/=iDivisor;
		}	
		else
			return iMin*(--iDivisor);
		iDivisor++;	
	}
}

Und was, wenn ich nicht 4, sondern nur 2 Werte habe, wie in deinem Beispiel "3, 8"?

Du hättest einfach copy&pasten können:

int ggt (int x, int y)
{
	while (true)
	{
		if (x == 0)
			return y;
		y %= x;

		if (y == 0)
			return x;
		x %= y;
	}
}

int kgv (int x, int y)
{
	int tmp = ggt (x, y);

	if (tmp == 0)
		return 0;

	return x / tmp * y;
}

int ggt (int * numbers, int count) 
{ 
	assert (count >= 2); 

	int result = ggt (numbers[0], numbers[1]); 

	for (int * it=numbers+2; it!=numbers+count; ++it) { 
		result = ggt(result, *it); 
	} 
	return result; 
}

int kgv (int * numbers, int count) 
{ 
	assert (count >= 2); 

	int result = kgv (numbers[0], numbers[1]); 

	for (int * it=numbers+2; it!=numbers+count; ++it) { 
		result = kgv(result, *it); 
	} 
	return result; 
}

Verwendung:

int foo[] = {3,4,2,1};
int bar[] = {8,12};

int ggtFoo = ggt(foo, 4);
int kgvFoo = kgv(foo, 4);

int ggtBar = ggt(bar, 2);
int kgvBar = kgv(bar, 2);

Musst dann halt nur einen Algorithmus schreiben.

Schau mal auf Wikipedia: Euklidischer Algorithmus

ULONG MyKgv(std::vector<ULONG> &vM){

	ULONG lMaxVielfaches=1,lDivisor=1;
	std::vector<ULONG>::iterator it = vM.begin();

	//Maximales Vielfaches als Startwert...
	for(; it< vM.end(); it++)
		lMaxVielfaches*= *it;

	//Kleinster Vielfaches ermitteln
	while(1){	
		it = vM.begin();
		for(; it< vM.end(); it++){
			if(lMaxVielfaches%(*it))
				return lMaxVielfaches*(--lDivisor);
		}
		if(lMaxVielfaches%lDivisor)
			return lMaxVielfaches;
		lMaxVielfaches/=lDivisor++;
	}
}