[C] 2 Klausuraufgaben, C-Funktion schreiben

[New C´ler]

Also ich leg mal los:

1.

Schreiben sie eine rekursive C-Funktion

unsigned binom(unsigned n, unsigned k)

die als Rückgabewert den entsprechenden Binomialkoeffizienten n über k liefert.
Die Binomialkoeffizienten sollen nach folgender Definition berechnet werde:

http://home.arcor.de/rydic/klaus..JPG

2.

Schreiben sie eine C-Funktion

float prod(float *faktor1, float *faktor2, int n)

die als Rückgabewert das Skalarprodukt zweier Vektoren liefert. Die beiden Vektoren werde durch die Zeiger *faktor1 und bzw. duchr *faktor2 an die Funktion übergeben.
Jeder der Vektoren hat n Elemente

______
So, bei der ersten, nuja, da fänd ichs toll, wenn mir da mal jmd helfen würde un diese rekursive funktion schreiben würde, in einfachster form, wenns geht

Bei der zweiten würd ichs so machen, dass ich eben zwei eindimensionale arrays der länge/größe n anlegen würde un dann mit ne while schleife mit abbruchbedingung i<n oder so return (faktor1 x faktor2[k] ); die berechnung zurückgeben lass während i bei jedem durchlauf eben erhöht wird.

Ist das wohl so machbar?


Danke für eventuelle antworten

 

[Stewi]

Bring selber Ansätze, zeig was du bis jetzt schon gecodet hast.
Du wirst sicherlich nicht erwarten, daß die Leute dir deine Hausaufgaben/Klausuren schreiben, oder?

 

[New C´ler]

jah zu 2.

float prod(float *faktor1, float *faktor2, int n){
  while (n>=0)
     return (faktor1[n--] * faktor2[n--] );
     
}

vorher sollten halt arrays der länge n mit eben den werten [an der stelle n] gefüllt werden, auf die die Pointer dann zeign un diese multiplizieren.


PS:
sind nicht meine Hausaufgaben, lediglich Aufgaben aus Klausuren, die ich mir selbst zusammgengesucht hab.

 

[dcdead]

Der Code, den du gepostet hast wird aber nicht funktionieren, da du direkt beim ersten multiplizieren die Funktion wieder verlässt.

Übrigens lassen sich beide Aufgaben wunderbar rekursiv lösen...

 

[New C´ler]

hmm, ja kann mir vorstellen, dass das bei der zweiten rekursiv geht...

ich studier nich informaitk oder so...das is bei uns eher nur nen nebenfach. ich versteh zwar funktionen, wenn ich sie seh aber selbst welche schreibn is dann immer ne andere sache...

also bei der zweiten, soll nich rekursiv sein...wieso verlass ich die funktion bei der multiplikation?

EDIT:

axoh, wegen return, richtig?....ehm würde ich die funktion irgendwie jetz nochmals irgendwie aufrufen,hätte ich ja schon die rekursive lösung oder?

is wohl nich so die gute lösung die brechnung in der return zu machn...

 

[muesler]

wieso verlass ich die funktion bei der multiplikation?

Weil eine Funktion nunmal mit 'return' verlassen wird.

Du solltest Dir die Ergebnisse schliesslich in einem Array merken (wie Du schon richtig bemerkt hast)...

 

[dcdead]

Mal so auf die schnelle ne rekursive Lösung für die 2.

float prod(float *faktor1, float *faktor2, int n){
while (n>=0)
return ((faktor1[n] * faktor2[n--]) + prod(faktor1, faktor2, n));
}

Damit multiplizierst du die 2 aktuellen Faktoren, gehst um ein n "weiter" und rufst die Funktion rekursiv mit dem neuen n auf.

Edit: Grad gelesen, dass die nicht rekursiv sein soll Dann kannst du's praktisch so lassen, musst nur das ergebnis zwischenspeichern:

float prod(float *faktor1, float *faktor2, int n)
{
int tmp = 0;
while (n>=0)
tmp += (faktor1[n] * faktor2[n--] );
}

 

[New C´ler]

okey

float prod(float *faktor1, float *faktor2, int n){ 
  while (n>=0) {
      P=faktor1[n]*faktor2[n];
      printf("%g",P);
      --n;
    }}

oder rekursiv

float prod(float *faktor1, float *faktor2, int n){ 
      P=faktor1[n]*faktor2[n];
      printf("%g",P);
      --n;
     prod();
    }

EDIT hab grad gesehn, dass du schon geantwortet hast

aber kann das sein, dass dein code auch falsch ist, hab ich eben bei mir gemerkt durch

tmp += (faktor1[n--] * faktor2[n--] );

wird n um 2 erniedrigt, soll ja nur um eins erniedrigt werden, oder?

 

[dcdead]

Ne, so wird das nicht funktionieren... Vergleich mal mit den beiden Varianten aus meinem letzten Post - vielleicht merkst du dann selbst wieso

 

[New C´ler]

ok in meiner rekursiven fehlt das (faktor1, faktor2,n) in der klammer...

aber was ich nich verstehen, in deiner nichrekursiven Lösung...multiplizierst du doch alle faktoren un speicher sie in tmp, das heißt die summe der produkte...

ein skalarprodukt sieht doch aber so aus:

1              4           4
3      *      -2     =    -6
7              1           7

oder versteh ich deine funktion falsch

 

[dcdead]

Ja, und die Zahlen aus dem Ergebnisvektor addierst du und bekommst einen Skalar (sprich eine normale Zahl). Jedenfalls ist das laut wikipedia so

 

[New C´ler]

okey, hier nochmal ne ander schöne aufgabe
3.
es soll ein C-Programm geschrieben werde, was der Tastatur ganze Zahlen entnimmt, x,y und dann die Zahl x^y berechnet. Es ist nur ganzzahlarithmetik erlaubt, also kein float oder double, deswegen fällt pow() schonmal raus, is glaub ich auch sinn der sache.

ich hab schonmal erkannt, dass man das bestimmt rekursiv machen kann...hab auch schon was, nur das ergebnis stimmt nich, ich weiß auch warum , weil eben in meiner funktion beim x=x*x der bock ist....ich weiß schon im kopf wies richtig is, nur kann ichs nich umsetzn, hier mal der code

kann mir vlt jmd noch weiterhelfen, sicher bestimmt, ihr cracks

#include <stdio.h>
#include <stdlib.h>

int hoch(int x, int y){
  while(y>0)
  return (x=x*x,y--,hoch(x,y));
}  

int main(){
  
  int a,b;
  
  printf("Zahl a, b eingeben");
  scanf("%d %d",&a,&b);

  printf("\n%d",hoch(a,b));

  return EXIT_SUCCESS;
}

 

[New C´ler]

ooops war n doppelpost

 

[dcdead]

Wie wär's einfach mit:

int hoch(int x, int y)
{
if (y == 0)
return 1;
for (int i=0; i<y; i++)
x *= x;
return x;
}



Und btw: Dein Code ist böse, weil da sehr leicht ein Buffer Overflow entstehen kann durch das scanf, da dieses nicht die Länge der gelesenen Zeichen checkt und somit über den Buffer drübergeschrieben werden kann.

 

[New C´ler]

ehhh hmmm....

wenn ich die funktion übernehme wirfts mir das hier aus

declaration of `x' shadows a parameter

außerdem versteh ich nich wie das ne berechnung durchführen soll....da x= x*x wenn x=0 ist, doch eh 0 ergibt?!

 

[hasugoon]

#include <iostream>
using namespace std;

int rek(int x, int y);

void main()
{
	cout << rek(2,5);	//32
	cin.get();
}


int rek(int x, int y)
{
	if (y==0)
		return 1;
	else
		return x*rek(x,y-1); 
}

edit: ich seh grade das is c einfach entsprechende i/o und es sollte genauso gehn

 

[dcdead]

ehhh hmmm....

wenn ich die funktion übernehme wirfts mir das hier aus

declaration of `x' shadows a parameter

außerdem versteh ich nich wie das ne berechnung durchführen soll....da x= x*x wenn x=0 ist, doch eh 0 ergibt?!

Sorry, das x brauchst du nicht zu deklarieren, keine Ahnung wie das da reingerutscht ist

 

[hasugoon]

@dcdead: 2^3 soll als beispiel die zahl 8 ergeben (2*2*2) und x^0 is immer 1. dein code-beispiel erfüllt die anforderungen leider überhaupt nicht ;>

 

[dcdead]

Ja, seh's auch grad War wohl bisschen spät gestern

So, hier jetzt mal ne iterative Variante, die auch funktioniert:

int hoch(int x, int y)
{
           int z=1;
           if (y == 0)
                return 1;
           for (int i=0; i<y; i++)
               z *= x;
           return z;
}

 

[7H3 N4C3R]

 return (faktor1[n--] * faktor2[n--] );

Dieser Code, sowie alle Derivate innerhalb dieses Threads, birgt undefiniertes Verhalten.

Die Auswertungsreihenfolge von n-- ist nicht festgelegt. Daher könnte entweder faktor1[n] * faktor2[n-1] oder faktor1[n-1]*faktor2[n] ausgerechnet werden. Jeder vernünftige Compiler sollte hierzu eine Warnung ausgeben.


Edit:
Sammlung des restlichen undefiniertes Codes, alles aus selbigem Grund:

return ((faktor1[n] * faktor2[n--]) + prod(faktor1, faktor2, n));
tmp += (faktor1[n] * faktor2[n--] );
return (x=x*x,y--,hoch(x,y));

Wobei letzte Zeile schon einen Eintrag auf The Daily WTF wert ist. *scnr* Also das ist mal absoluter Missbrauch des Sequenzoperators.