3. max(a, b, c, d) mit bedingunen => ????

max(a, b, c, d) mit bedingunen => ????

  • L

    hi,

    ich brauch ein algorythmus um das maximum von vier zahlen zu ermitteln. die zahlen stehen in einem array:

    int iaZahlen[4] = {a, b, c, d};

    wenn das maximum nicht eindeutig ist, d.h. 2 oder 3 zahlen den gleichen wert haben (4 kann man ausschließen), dann gilt die zahl als maximum, die den größten index im array hat.

    !!!!!! 😮 😕 😮 😕 😮 !!!!!!
    ich hab kleinen plan wie ich das machen soll !
    deshalb brauch ich dringend hilfe. irgendwelche lösungsansätze. egal.

    danke im vor*aus.
    lw

    0
  • G

    mhhh, das hab ich jetzt mal in 2min zusammen gewürfelt. keine ahnung ob's klappt:

    PS: ist pseudocode!

    int Max(Zahl[4])
{
int Max;
if(Zahl[0] > Zahl[1])
Max = Zahl[0];
else
Max = Zahl[1];
if(Max < Zahl[2])
Max = Zahl[2];
if(Max < Zahl[3])
Max = Zahl[3];
return Max;
}

    müsste in etwa hinhauen. Macht aber nicht komplett dass was du willst. müsste aber als denkanstoss reichen!

    0
  • M

    Du nimmst Dir eine Variable "max" und setze sie auf das erste element(hier also a). Dann vergleichst Du sie mit jedem Element, nur wenn a<das nächste Element, dann setze a=dieses element. Gleichzeitig merkst Du Dir in einer anderen Variable "i" die Position des aktuellen "max". Das machst Du bis Ende, egal wie viele Elemente das Array hat. Das Ganze kann man in 3 Zeilen umsetzen.

    Ich hoffe, das kann helfen
    mnab

    0
  • N

    Wie wärs denn mit std::max_element()?

    0
  • C

    @nman:
    hmm...aus der MSDN:

    The first template function determines the lowest value of N in the range [0, last - first) such that, for each M in the range [0, last - first), the predicate *(first + N) < *(first + M) is false. It then returns first + N. Thus, the function determines the lowest position that contains the largest value in the sequence.

    Das interpretiere ich mal so, daß bei gleichem Max-Wert das Element mit dem _niedrigsten_ Index zurückgegeben wird.

    so sollte es gehen:

    int MaxInArray(int Values[],int Count/*number of elements in array*/)
{
    int i,max=0;
    for (i=0;i<Count;++i)
    {       
        if (Values[i]>=Values[max]) max=i;
    };
    return max;
};
    0
  • L

    edit: hat doch tatsächlich jemand vor mir gepostet.

    danke. hab's hinbekommen. 🙂

    const int length = 4;
int iaZahlen[length] = {a, b, c, d};
int iMax = 0;
for(int i = 1; i < length; i++) {
    if(iaZahlen[iMax] <= iaZahlen[i]) {iMax = i;}
}
//return iMax;

    max_element() ist nicht geeignet, da dort die zusatzbedingung nicht beachtet wird. 🙄

    *happy* 😃
    lw

    [ Dieser Beitrag wurde am 23.04.2003 um 14:18 Uhr von Lawilog editiert. ]

    0
  • N

    Ist mir schon klar, ich meinte auch nur dass die Implementierung ja als Ausgangspunkt einer eigenen Funktion verwendet werden kann:

    // so sieht das max_element auf meinem rechner aus:
template <class _ForwardIter>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) {
  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__result < *__first)
      __result = __first;
  return __result;
}

    form das hierzu um und alles passt:

    template <class ForwardIter>
ForwardIter myMax_element(ForwardIter first, ForwardIter last)
{
  if (first == last)
    return last;
  ForwardIter result = first;
  while (++first != last)
    if (*first >= *result) // das ist die einzig "nicht-kosmetische" Änderung
      result = first;
  return result;
}

    Natürlich muss im grunde nur "if (*__result < *__first)" zu "if (*__result <= *__first)" geändert werden, aber ich finde das so lesbarer.

    [ Dieser Beitrag wurde am 23.04.2003 um 14:24 Uhr von nman editiert. ]

    0
  • V

    Oder man nimmt den reverse_iterator:

    #include <iostream>
#include <iterator>
#include <algorithm>

int main()
{
    int a[] = { 1, 2, 3, 6, 4, 4, 6, 0, 2};
    std::reverse_iterator<int*> ende(a);
    std::reverse_iterator<int*> anfang(a + sizeof(a)/sizeof(a[0]));
    std::reverse_iterator<int*> pos = std::max_element(anfang, ende);

    std::cout<< "Max. Element hat den Wert " << *pos
             << "Und ist an Position " << (pos.base()-a-1) <<std::endl;
}

    [ Dieser Beitrag wurde am 23.04.2003 um 15:13 Uhr von virtual editiert. ]

    0
  • N

    Shit, genau das ist mir an der Busstation eingefallen, ich habe ein paar Sekunden echt überlegt ob ich schnell zurück laufen soll und meinen Post ausbessern soll 🙂

    0
  • M

    Original erstellt von nman:
    echt überlegt ob ich schnell zurück laufen soll und meinen Post ausbessern soll

    toll, alles was man in diesem Forum sieht 😃

    0
Anmelden zum Antworten