Algorithums größer/kleines gemeinsamer Teile mehrer zahlen?

Helium

Prinzip ist das Selbe:

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>)

aber dann komm ja immer nur "1" raus!!

Helium

Wobei kommt 1 raus?
Der ggt von 3, 4 , 7, 6 ist tatsächlich 1! Probier mal ... was weiß ich, 4, 8, 12, 28. Sollte dann 4 sein.

wies sieht die funktion kgv() aus?

Helium

Wie gesagt. genau, wie ggt, nur eben mit kgv:

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; 
}

ok danke für dein Bemühen... ich werde den code posten wenn es funzt;)

Helium

Wieso, was funktioniert denn noch nicht?

will boost nich verwenden....!!!

Value = Multipliaktion aller Zahlen miteindander als startwert!

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++;	
	}
}

Helium

WTF? da weiß ich ja nichtmals, wie ich das aufrufen soll.

int aiWerte[4] = {3,4,2,1};

//3*4*2*1= 24

int Erg= divisor(24,aiWerte);

Helium

Und die 24 rechne ich im Kopf aus?

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);

oh danke.. perfekt;)

matimatiker

wie wärs mit: kgv( zahlen ) = Produkt(Zahlen) / ggt(Zahlen)

Musst dann halt nur einen Algorithmus schreiben.

Das was du suchst ist wird Euklidischer Algorithmus genannt.

Schau mal auf Wikipedia: Euklidischer Algorithmus

BorisDieKlinge

sowas wie:

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++;
	}
}