Funktion die bestimmt ob Elemente Gerade sind

TylerDurden0903

Hallo Leute!

Ich soll eine Funktion bool alleven(int feld[],int anzahl) schreiben die für ein übergebenes (feld) in dem anzahl Elemente gespeichert sind, bestimmt, ob alle Elemente gerade sind. Falls sich keine Elemente darin befinden so ist das Ergebnis true.

bool alleven(int feld[],int anzahl)
{
    bool ergebnis
	if (anzahl==0)
	{
	return true;
	}
	else
	{
		ergebnis= alleven(feld, anzahl-1);
		if (ergebnis==true)
		{
			if (feld[anzahl-1]%2==0)
			{
				return true;
			}
		      else 
			{
				return false;
			}
		}
		return false;
	}
}

Ist das so korrekt?

knivil

Ja, wobei sehr umstaendlich.

314159265358979

bool alleven(int feld[], int anzahl)
{
    return std::find_if(feld, feld + anzahl, [](int n) { return n % 2; }) == feld + anzahl;
}

SeppJ

Das sieht korrekt aus, aber extrem umständlich. Wie wäre es mit einer kleinen Schleife? Dann wird das zu einem Dreizeiler.

edit: Zu langsam.

Bashar

SeppJ schrieb:

Das sieht korrekt aus, aber extrem umständlich. Wie wäre es mit einer kleinen Schleife? Dann wird das zu einem Dreizeiler.

Ist das ein Ein- oder ein Vierzeiler?

bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

314159265358979

Leere Felder gibts übrigens nicht.

hustbaer

@314159265358979:
Ja, ist natürlich immer gut, Spezialfälle nicht zu berücksichtigen, von denen man meint sie wären sowieso verboten.

Bashar schrieb:

bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

Etwas Offtopic, aber das frage ich mich schon länger.

Wo steht im C++ Standard, dass der linke Ausdruck "anzahl == 0" als erstes Abgearbeitet wird? Und bei true die rechte Seite nicht weiter verarbeitet wird?

Das es so ist, dass kann man ja ausprobieren. Aber ist das Standard-Konform?

314159265358979

hustbaer schrieb:

@314159265358979:
Ja, ist natürlich immer gut, Spezialfälle nicht zu berücksichtigen, von denen man meint sie wären sowieso verboten.

Stell dir vor, meine Funktion funktioniert trotzdem.

Bashar

Siassei - Auf der Arbeit schrieb:

Wo steht im C++ Standard, dass der linke Ausdruck "anzahl == 0" als erstes Abgearbeitet wird? Und bei true die rechte Seite nicht weiter verarbeitet wird?

Da, wo der || Operator beschrieben wird (5.15§1).

volkard

TylerDurden0903 schrieb:

Hallo Leute!

Ich soll eine Funktion bool alleven(int feld[],int anzahl) schreiben die für ein übergebenes (feld) in dem anzahl Elemente gespeichert sind, bestimmt, ob alle Elemente gerade sind. Falls sich keine Elemente darin befinden so ist das Ergebnis true.
bool alleven(int feld[],int anzahl)
{
    bool ergebnis
	if (anzahl==0)
	{
	return true;
	}
	else
	{
		ergebnis= alleven(feld, anzahl-1);
		if (ergebnis==true)
		{
			if (feld[anzahl-1]%2==0)
			{
				return true;
			}
		      else 
			{
				return false;
			}
		}
		return false;
	}
}
Ist das so korrekt?

Ja, sieht guut aus.

Aber Mega-Umständlich.

bool alleven(int feld[],int anzahl)
{
    bool ergebnis;//Nee, erst später definieren, erst, wenn man sie sinnvoll initialisieren kann
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        ergebnis= alleven(feld, anzahl-1);
        if (ergebnis==true)
        {
            if (feld[anzahl-1]%2==0)
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        bool ergebnis= alleven(feld, anzahl-1);//ach, dann kann sie auch weg
        if (ergebnis==true)
        {
            if (feld[anzahl-1]%2==0)
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            if (feld[anzahl-1]%2==0)//Trick 17
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

Trick 17:
if(ausdruck==true) return true; else return false; ist identisch zu und meistens besser zu lesen als return ausdruck;

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            return feld[anzahl-1]%2==0;
        }
        return false;
    }
}

Oh, in eine Optimier-Sackgasse getappt. Zurück.

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            if (feld[anzahl-1]%2==0)//Nee, nicht Trick 17, sondern Trick 18 rückwärts
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

Trick 18: if(A && cmd; ist identisch zu und oft besser zu lesen als if(A) if(B) cmd;

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0)//17
        {
            return true;
        }
        else
        {
            return false;
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
        return false;//UUps, woher kommt die Leiche denn?
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
        return true;
    }
    else
    {
        return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return alleven(feld, anzahl-1) && feld[anzahl-1]%2==0;
}

Und dann vielleicht noch

bool isEven(int n)
{
    return n%2==0;
}
bool areAllEven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return areAllEven(feld, anzahl-1) && isEven(feld[anzahl-1]);
}

Aber ich hätte keine Rekursion genommen, sondern eine Schleife. Die fällt dann auch zusammen, ungefähr zu sowas:

bool areAllEven(int feld[],int anzahl)
{
    for(int i=0;i<anzahl;++i)
       if(!isEven(feld[i])
           return false;
    return true;
}

SeppJ

Bashar schrieb:

SeppJ schrieb:

Das sieht korrekt aus, aber extrem umständlich. Wie wäre es mit einer kleinen Schleife? Dann wird das zu einem Dreizeiler.

Ist das ein Ein- oder ein Vierzeiler?
bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

In meiner obigen Zählweise hätte ich das als Einzeiler bezeichnet, weil es ein einziger Ausdruck ist. Aber das ist ja auch wieder die rekursive Variante. Ich hätte (um etwas anfängerfreundlich zu sein als 314159265358979s Version) die letzte Version von volkard genommen:

bool areAllEven(int feld[],int anzahl)
{
    for(int i=0;i<anzahl;++i)
       if(!isEven(feld[i])
           return false;
    return true;
}

Habe mich aber wohl verzählt als ich im Kopf programmiert habe und auf drei Zeilen gekommen bin. Aber man könnte bestimmt irgendwie rechtfertigen, dass man das return false ind die gleiche Zeile wie das if schreibt :p .