fragen zu eine Programm

$|g|

hallo Leute, ich porgrammiere erst seit 1 Monat und habe noch nciht sehr viel Erfahrung

könnte mir vielleicht jemand einen kleinen Denkanschub zu folgender Aufgabe geben:

Eine Funktion int mult(int m, int n) und int power(int m, int n), die das Produkt m*n und die Exponentialfunktion m^n der zahlen m und n löst, jedoch keine Schleifen oder Mathematikibliotheken verweden und auch der operator * darf nicht verwendet werden
Hinwei: m*n=m+m*(n-1) fuer 0<n bzw. m^n=m*m^n-1
beachte das int werte auch negativ sein können oder auch gleich 0

ich ahbe leider fast keinen schimmer wie ich an diese aufgabe herangehen sollte, wäre nett wenn mir wer einen Rat gebenkönnte

MfG.: demoniacal preacher

MichiK

rekursiv lösen

es gilt:

m*n = m*(n-1) + m
m^n = m^(n-1) * m

als denkanstoß mit fakultät ("faktorielle") n!

es gilt:

n! = n*(n-1)!
0! = 1

int fakultaet(int n)
{
if (n > 0) return n*fakultaet(n-1); else return 1;
}

MfG, Michael

$|g|

gut ich werde es versuchen, jedoch das was mich verwirrt ist, daß in dem

m*n = m*(n-1) + m
m^n = m^(n-1) * m

erneut ein Operator * vorkommt, und ich den ja nicht verwenden darf, oder sollte das nur heissen, daß ich nicht einfach die "normale" m*n Varaiten nutzen soll?

lj_scampo

ganz grob skizziert (wenn ich den code hier poste, ist dir sicher auch nicht unbedingt geholfen):

multi:
zuerst musst du schauen, was passiert, wenn einer der beiden parametern negativ ist -> ergebnis = -multi(m', n' ), wobei m' und n' die zugehoerigen positiven werte von m und n sind.
was passiert, wenn beide neg. sind?
was passiert, wenn n=0 ist (also ergebnis von m*0)?
und dann die rekursion: m und n sind >0 -> ergebnis = m*(n-1)+m
aber fuer m*(n-1) musst du natuerlich wieder multi(.) aufrufen, da ja der *operator verboten ist.

power:
aehnliche ueberlegungen wie bei multi (fallunterscheidungen fuer negative werte) und zusaetzlich musst du das *, welches in der rekursiven formel vorkommt durch dein multi(.) ersetzen:
m^n= m^(n-1)*m = multi(m^(n-1),m);

auf diese weise kommt nirgens mehr ein * vor.

hoffe, das hilft dir weiter

$|g|

das Programm ist nun soweit fertig, nur:

ich versuche das jetzt schon etwas länger für die "negative Multipliaktion", wie mache ich es das er die negativen werte also entweder wenn das n oder m halt negativ ist in positive umwandelt um mit denen dann die -mult(blabla) löst?

ich würde beide ja mit (-1) Multiplizieren, aber dies darf ich ja nicht verwenden

ich stehe geade sehr auf der Leitung wie das funktionieren soll...thx falls jemand mir helfen kann

lj_scampo

-multi(-m,n) falls m negativ war.
hier mal zwei loesungsvorschlaege:

einfache version:

Code

{
  if ((m==0) || (n==0)) return 0; /* rekursionsabbruch */
  elseif ((m<0) && (n<0)) return multi(-m,-n); /* beide negativ -> positives ergebnis */
  elseif (m<0) return -multi(-m,n); /* nur m neg. */
  elseif (n<0) return -multi(m,-n); /* nur n neg. */
  /* an dieser stelle sind sicher beide positiv! */
  return multi(m, n-1)+m; /* beide positiv */
}

schneller sollte es mit folgendem code gehn, da hier (ausser bei m=n) die rekursionstiefe kleiner ist und die if-anweisungen nur einmal gecheckt werden, nicht bei jeder rekursion:
aufruf mit multi(m,n)

Code

mehtode multi:
{
  if ((m<0) && (n<0))
  {/* beide negativ -> positives ergebnis */
    m=-m;
    n=-n;
  }


  /* nur ein parameter neg. -> neg. ergebnis: */
  if (m<0) return -multi(-m,n);
  if (n<0) return -multi(m,-n);


  /* zur minimierung der rekursionstiefe: */
  if(m<n) return multi_rev(n,m); /*umtauschen! */
  else return multi_rev(m,n);
}






mehtode multi_rec:
{
  if ((m==0) || (n==0)) return 0; /* rekursionsabbruch */
  return multi_rec(m, n-1) +m;
}

Alles anzeigen

hoffe, das hilft weiter und du verstehst es auch. habe den code hier allerdings "blind" geschrieben, d.h. nicht compiliert. kann also sein, dass kleinere fehler drin sind, aber der programmablauf sollte passen.

mfg

$|g|

thx ;]

und proggi arbeitet, thx jetzt habe ich mal eine Ahnung wie das ganze funzt!

:coolsmile

Jetzt mitmachen!