a+b+c+d==a*b*c*d==7.11

b7f7

bedeutet bei dir positiv auch nicht 0?
unsin hab das mit der 7.11 übersehn

volkard

freshman schrieb:

Rätsel: vier Zahlen (positiv, max 2 Nachkommastellen) ergeben sowohl addiertals auch miteinander multipliziert 7.11. Welche Zahlen ?

bitte mach das prog nicht so lahm.
mach erstmal ints draus. also tranformiere das rätsel:
Rätsel: vier ganze Zahlen (positiv) ergeben sowohl addiertals auch miteinander multipliziert 711. Welche Zahlen ?

dann knack die 711. welche teiler hat sie überhaupt? brauchst nur die zu nehmen, statt aller zahlen von 1 bis 711.

tag

volkard schrieb:

vier ganze Zahlen (positiv) ergeben sowohl addiertals auch miteinander multipliziert 711.

Sicher? Ich würde sagen

a + b + c + d    =  a * b * c * d  = 7.11   | *100
<=> 100a+100b+100c+100d =   100*a*b*c*d   = 711

Das zeigt IMHO schon, dass man nicht mit ganzen Zahlen rechnen kann. 100*z kann nicht 711 ergeben.

Oder habe ich etwas übersehen?

b7f7

die lösung ist eigentlich nicht so hart
wenn a=b=c = z
dann ist es simpel nichtlinear

7.11=3z+d
7.11=z^3d

z=2.121946767
d=0.7441597

assoso die Rechnung

\[f1:= 7.11=3*z+d]\ \[f2:= 7.11=z^3*d]\ start z=2 , d=1 Taylor polynom um zu N"ahern \[f1'\delta z := 3\] \[f1'\delta d := 1\] \[f2'\delta z := 3\*z^2\*d\] \[f2'\delta d := z^3\] \[\delta f1 :=3*\delta z + 1*\delta d\] \[\delta f2 :=3\*z^2\*d*\delta z + z^3*\delta d\] \[ \left( \begin{array}{cc} 3 & 1\\ 3\*z^2\*d & z^3\\ \end{array} \right) * \left( \begin{array}{c} \delta z\\ \delta d\\ \end{array} \right) = \left( \begin{array}{cc} \Delta f1\\ \Delta f2\\ \end{array} \right) \]

nach code

void calcABCD()
{
  // wenn a=b=c=d; => 7.11=4*a
  double soll=7.11;
  double eps=numeric_limits<double>::epsilon();
  double z=soll/4.0;
  double d=z-1; // Singularität beseitigen
  double f1; // nur der uebersicht wegen
  double f2;
  double df1,df2,uz,ud;
  double df1z(3.0),df1d(1.0),df2z,df2d;
  double a00,a01,a10,a11,det;
  do
  {
    f1=3.0*z+d;
    f2=z*z*z*d;
    df1=soll-f1;// delta Soll Ist Werte
    df2=soll-f2;
    df2z=3.0*z*z*d;// Ableitungen rechnen
    df2d=z*z*z;
    det=1.0/(df1z*df2d-df2z*df1d);//Rezip. der Determinante der Jacobi matrix
    a00=df2d*det;// Invertieren
    a01=-df1d*det;
    a10=-df2z*det;
    a11=df1z*det;
    uz=a00*df1+a01*df2; // Update rechnen
    ud=a10*df1+a11*df2;
    z=z+uz; // werte updaten
    d=d+ud;
  }while(sqrt(uz*uz+ud*ud)>eps);
  cout<<z<<"+"<<z<<"+"<<z<<"+"<<d<<"="<<z+z+z+d<<endl;
  cout<<z<<"*"<<z<<"*"<<z<<"*"<<d<<"="<<z*z*z*d<<endl;
}
output
2.12195+2.12195+2.12195+0.74416=7.11
2.12195*2.12195*2.12195*0.74416=7.11

volkard

b7f7 schrieb:

die lösung ist eigentlich nicht so hart
...
2.12195+2.12195+2.12195+0.74416=7.11
2.12195*2.12195*2.12195*0.74416=7.11

zweistellig sollten die eingangszahlen sein.

volkard

tag schrieb:

volkard schrieb:

vier ganze Zahlen (positiv) ergeben sowohl addiertals auch miteinander multipliziert 711.

Sicher? Ich würde sagen
a + b + c + d    =  a * b * c * d  = 7.11   | *100
<=> 100a+100b+100c+100d =   100*a*b*c*d   = 711
Das zeigt IMHO schon, dass man nicht mit ganzen Zahlen rechnen kann. 100*z kann nicht 711 ergeben.

Oder habe ich etwas übersehen?

kann sein.
ich hab auch was übersehen.
richtig ist eher sowas:

(1) a*b*c*d=7.11
(2) a+b+c+d=7.11
jetzt will ich erstmal auf ganze zahlen kommen
(3) e:=100*a;f:=100*b;g:=100*c;h:=100*d

(4) e/100*f/100*g/100h/100=7.11 //aus (1) mit (3)
(5) e*f*gh/100000000=7.11
(6) e*f*gh/1000000=711
(7) e*f*gh=711000000
naja, hoffentlich bringt (7) was.

(8) e/100+f/100+g/100+h/100=7.11 //aus (2) mit (3)
(9) e+f+g+h=711
jo, bringt was.
(a) wegen (7) können e,f,g,h jeweils nicht 0 sein.
(b) wegen (9) und (a) müssen e,f,g,h jeweils kleiner als 711 sein.
(c) wegen (7) müssen e,f,g,h teiler von 711000000 sein.

mal sehen. teiler von 711000000 kann es ja nicht so viele geben. vor allem, wenn sie zwischen 1 und 710 liegen sollen.

#include "iostream.h"
int main()
	for(int i=1;i<711;++i)
		if(711000000%i==0)
			cout<<i<<' '

ausgabe: 1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,30,32,36,40,45,48,50,60,64,72,75,79,80,9
0,96,100,120,125,144,150,158,160,180,192,200,225,237,240,250,288,300,316,320,360
,375,395,400,450,474,480,500,576,600,625,632,

jo, das ist lieb vom problem.

das will ich gleich in ein programm einbasteln.

#include "iostream.h"
int main()
	int begin[]={1,2,3,4,5...}
	int *end=begin+sizeof(begin)/sizeof(begin[0])
	for(int *e=begin;e!=end;++e)
		for(int *f=begin;f!=end;++f)
			for(int *g=begin;g!=end;++g)
				for(int *h=begin;h!=end;++h)
					if(*e+*f+*g+*h!=711)
						continue
					if(*e**f**g**h!=711000000)
						continue
					cout<<*e<<' '<<*f<<' '<<*g<<' '<<*h<<'\n'

ausgabe:
120 125 150 316
120 125 316 150
120 150 125 316
120 150 316 125
120 316 125 150
120 316 150 125
125 120 150 316
125 120 316 150
125 150 120 316
125 150 316 120
125 316 120 150
125 316 150 120
150 120 125 316
150 120 316 125
150 125 120 316
150 125 316 120
150 316 120 125
150 316 125 120
316 120 125 150
316 120 150 125
316 125 120 150
316 125 150 120
316 150 120 125
316 150 125 120

rechenzeit unmerklich, also keine weiteren optimierungen nötig.

probe:
3,16+1,50+1,25+1,20 mit copy&pase in den windows-taschenrechner: ausgabe 7.11
3,16*1,50*1,25*1,20 mit copy&pase in den windows-taschenrechner: ausgabe 7.11

ich bin nicht ursächlich wegen der geschwindigkeit nach int gegangen, sondern weil
doubles nicht genau genug sind. 7.11 ist als binärzahl ein unendlicher binärbruch, der
irgendwo am ende immer ungenauigkeiten aufzuweisen hat. die hätte ich versuchen können,
mit geschickten rundungen und wirren vergleichen abzufangen, aber das wird viel zu
kompliziert und bleibt immernoch ungewiß. bei int gibt es keine rundungsfehler.

ich vermute, dein programm wird deswegen mit doubles nie klappen.

Jester

volkard schrieb:

#include "iostream.h"
int main()
	int begin[]={1,2,3,4,5...}
	int *end=begin+sizeof(begin)/sizeof(begin[0])
	for(int *e=begin;e!=end;++e)
		for(int *f=e;f!=end;++f)
			for(int *g=f;g!=end;++g)
				for(int *h=g;h!=end;++h)
					if(*e+*f+*g+*h!=711)
						continue
					if(*e**f**g**h!=711000000)
						continue
					cout<<*e<<' '<<*f<<' '<<*g<<' '<<*h<<'\n'

Dürfte die doppelten rauswerfen. Es ist klar, daß alle Permutationen auch Lösungen sind.

freshman

super! vielen Dank an alle!
while(1){cout<<" thanx' ";}
@volkard: so ähnlich sieht meine zweite Version auch aus
Das ursprüngliche Problem lag wirklich an den Rundungsfehlern durch die falsche Wahl des Datentyps 'double'
Denkt aber bitte nicht, daß die erste Version meinem Style entspricht
War als negativ-Beispiel für Performance gedacht
(eigentlich wollte ich nur eine 100%ige CPU-Auslastung über einen längeren Zeitraum erzielen, um während dessen an meinem Tower zu rütteln, um zu schauen wie lange die Platte das aushält ne, ne, keine Sorge)

freshman

kann mir noch jemand sagen, wie ich am einfachsten(!) beim Herausfinden der Teiler von 7,11*100^4 das int-Array faktor[] dynamisch allokieren kann?
*this :

int h=0,
		faktor[100],//unschön, stattdessen dynamisch allokieren!
		numOfFaktors=0,
		numOfResults=0,
		resA=711,
		resM=711000000,
		resTempA1=0,resTempA2=0,resTempA3=0,
		resTempM1=0,resTempM2=0,resTempM3=0;
	    string datei;

	cout<<"Bitte Pfad der Datei eingeben, in der das Ergebnis gespeichert werden soll!"<<endl; 
	cout<<"Kompletter Zielpfad: "; 
	cin>>datei; 
	ofstream outDat(datei.c_str());

	for(int i=2; i<711 ;i++){								 
		if(711000000%i==0){ 
			faktor[numOfFaktors++] = i;
		}
	}
	for(int pos0=0; pos0<numOfFaktors ;pos0++){
		for(int pos1=0; pos1<numOfFaktors ;pos1++){
			resTempA1=faktor[pos0]+faktor[pos1];
			resTempM1=faktor[pos0]*faktor[pos1];
			for(int pos2=0; pos2<numOfFaktors ;pos2++){
				resTempA2=resTempA1+faktor[pos2];
				resTempM2=resTempM1*faktor[pos2];
				h = resA-resTempA2;
				resTempA3=resTempA2+h;
				resTempM3=resTempM2*h;
				if(resTempA3==resA && resTempM3==resM){
					outDat<<endl<<"Ergebnisnr.: "<<++numOfResults<<endl
						  <<"  a="<<setw(4)<<setfill(' ')<<double(faktor[pos0])/100
						  <<", b="<<setw(4)<<setfill(' ')<<double(faktor[pos1])/100
						  <<", c="<<setw(4)<<setfill(' ')<<double(faktor[pos2])/100
						  <<", d="<<setw(4)<<setfill(' ')<<double(h)/100<<endl;
				}
			}
		}	
	}

volkard

freshman schrieb:

kann mir noch jemand sagen, wie ich am einfachsten(!) beim Herausfinden der Teiler von 7,11*100^4 das int-Array faktor[] dynamisch allokieren kann?

ja, zufällig geht das mit vector und push_back super.

volkard

freshman schrieb:

(eigentlich wollte ich nur eine 100%ige CPU-Auslastung über einen längeren Zeitraum erzielen, um während dessen an meinem Tower zu rütteln, um zu schauen wie lange die Platte das aushält

wenn dein rechner wieder etwas zeit hat, ich wollte schon immer mal erfahren, wie viele primzahlen es gibt, die kleiner als eine milliarde sind. schaffste das bis nächste woche?

freshman

@volkard: hier bitte schön! aber mein lieber, das hättest du aber auch selber hinbekommen!

int numOfPrim=0;
	for(int i=2; i<1000000000 ;i++){
		for(int j=2; j<i && i%j!=0 ;j++);
		if(i!=j){
			numOfPrim++;
		}
	}
	cout<<numOfPrim;

ich falle hier gleich vom Stuhl
while(1){cout<<" ";}
post scriptum: hoffentlich denkt keiner das wäre ernst gemeint