randomize()

Z1=random(5)
Z2=random(5)
Z3=random(5)
Z4=random(5)
Z5=random(5)
Z6=random(5)

Ich möchte kontrollieren ob 3 Zahlen gleich sind.

Nur wie stelle ich das an?

Danke schon mal.

MFG.

hat von euch vielleicht jemand kurz zeit mir solch einen array vorzustellen. hab keine ahnung wie ich das hinbekommen soll.

mfg.

Ich denke das sollte reichen. Allerdings solltest du das in einem guten Buch nachschalgen. Siehe mal im FAQ für Anfängerbücher.

@Fellhuhn
Das wollte ich zuerst auch machen, dachte aber, dass er sich gescheiter mit der Materie befässt, als es von uns lösen zu lassen.

int Z[5] = {random(5), random(5), random(5), random(5), random(5)};

danke danke.
ich hab einfach viel viel viel zu kompliziert gedacht.

Und das eigentliche Problem kommt ja erst noch. :p

also ihr wisst es ja schon das es kommt .
wie sortier und verlgeiche ich die zahlen?

DANKE

ok ich wollte es ja selbst lösen wenn ihr hier schon schreibt das dass problem erst kommen wird

also ihr wisst es ja schon das es kommt .
wie sortier und verlgeiche ich die zahlen?

DANKE

Ja, das haben wir erwartet Aber du kannst für den Anfang den Bubblesort-Algorithmus nutzen:

http://de.wikipedia.org/wiki/Bubblesort

florian.dulzky schrieb:

ok ich wollte es ja selbst lösen wenn ihr hier schon schreibt das dass problem erst kommen wird

also ihr wisst es ja schon das es kommt .
wie sortier und verlgeiche ich die zahlen?

DANKE

Ja, das haben wir erwartet Aber du kannst für den Anfang den Bubblesort-Algorithmus nutzen:

http://de.wikipedia.org/wiki/Bubblesort

klingt gut hab ich in einem buch auch mal gelesen davon

lg, freakC++

BubbleSort ist aber ineffizient. Wenn Du es professionell machen willst, dann steige auf MergeSort (QuickSort etc.) um.

Er will doch nur 5 oder 6 Zahlen sortieren. Da können diese Verfahren ihre Stärken nicht wirklich ausspielen, sie werden wohl sogar langsamer sein. Eine "professionelle" Herangehensweise sollte das berücksichtigen. Ernsthafte Quicksort-Implementierungen schalten auch bei kleinen Arrays auf einen naiven Algorithmus um. Vielleicht nicht gerade Bubble Sort, da gibt es ja noch einige andere.

BTW die einfachste Lösung benutzt eine map: Einfach immer Map[Zahl]++ und am Schluss gucken ob irgendein Element >= 3 ist. Wenn man völlig unbeleckt ist kriegt man nämlich den Algorithmus, drei aufeinanderfolgende gleiche Zahlen in einem sortierten Array zu finden, auch nicht ohne weiteres fehlerfrei hin.

lg, freakC++

Selbst ohne sortieren und STL sind es nur drei verschachtelte For-Schleifen mit zwei Abfragen.

Drei? Pff...

#include <iostream>

const int MAX_SIZE = 5;

int main()
{
	int a[MAX_SIZE] = {10, 30, 10, 30, 50};

	unsigned int i;
	unsigned int count;

	for (i = 0; i < MAX_SIZE; ++i)
	{
		count = 0;

		for (unsigned int j = 0; j < MAX_SIZE; ++j)
		{
			if (count >= 3)
			{
				break;
			}

			if (a[i] == a[j])
			{
				++count;
			}
		}

		if (count >= 3)
		{
			break;
		}
	}

	if (count >= 3)
	{
		std::cout << a[i] << std::endl;
	}
}

#include <iostream>

int checkOccurence(int *a, unsigned int size);

int main()
{
	const int MAX_SIZE = 5;

	int a[MAX_SIZE] = {10, 10, 10, 30, 50};

	int pos;
	if ((pos = checkOccurence(a, MAX_SIZE)) >= 0)
	{
		std::cout << a[pos] << std::endl;
	}
}

int checkOccurence(int *a, unsigned int size)
{
	for (unsigned int i = 0; i < size; ++i)
	{
		unsigned int count = 0;

		for (unsigned int j = 0; j < size; ++j)
		{
			if (a[i] == a[j])
			{
				if (++count >= 3)
				{
					return i;
				}
			}
		}
	}

	return -1;
}

Ist ja immernoch mit "count". Öööööde.... Außerdem werden nicht die Positionen ausgegeben.

Die Positionen waren auch nicht verlangt.

Falls man aber tatsächlich auf die Positionen scharf ist, so stellt meine Lösung alle notwendigen Angaben bereit, um diese zu finden.

Und wie sieht deine Variante aus? Jetzt bin ich neugierig. Was spricht gegen count ?

Und wie sieht deine Variante aus? Jetzt bin ich neugierig. Was spricht gegen count ?

Gegen meine Variante spricht Feierabend und gegen count spricht langweilig.

In etwa, schnell hingerotzt:

for(int i = 0; i < size - 2; ++i)
  for(int ii = i + 1; ii < size - 1; ++ii)
    if (ar[i] == ar[ii])
      for(int iii = ii + 1; iii < size; ++iii)
        if (ar[i] == ar[iii])
           ; // tu was immer nötig

sdfsdf schrieb:

Und wie sieht deine Variante aus? Jetzt bin ich neugierig. Was spricht gegen count ?

Gegen meine Variante spricht Feierabend und gegen count spricht langweilig.

In etwa, schnell hingerotzt:

for(int i = 0; i < size - 2; ++i)
  for(int ii = i + 1; ii < size - 1; ++ii)
    if (ar[i] == ar[ii])
      for(int iii = ii + 1; iii < size; ++iii)
        if (ar[i] == ar[iii])
           ; // tu was immer nötig

Nicht schön, aber selten Finde meine Lösung besser. Positionen lassen sich so rausfinden:

int pos;
	if ((pos = checkOccurence(a, MAX_SIZE)) >= 0)
	{
		for (unsigned int i = pos; i < MAX_SIZE; ++i)
		{
			if (a[i] == a[pos])
			{
				std::cout << "a[" << i << "] = " << a[i] << std::endl;
			}
		}
	}