Variabelen vergelijken in C++

Goedendag,

Ik ben beginner in het programmeren met C++ en vroeg me eigenlijk af, hoe ik 9 variabelen kan vergelijken met elkaar.

Ik weet, het klinkt een beetje vaag, daarom leg ik hier even uit wat ik wil:

Ik heb 9 variabelen, deze heten (bijv) a, b, c, d, e, f, g, h en i.
Deze variabelen kunnen allemaal een waarde hebben van 0 t/m 9.
Nou wil ik dus, dat als 2 (of meer) van deze variabelen dezelfde waarde hebben,
hij een melding geeft waarin staat "goedendag",
wanneer dit niet zo is, moet hij een melding geven waarin staat "tot ziens".
(de meldingen zijn gewoon willekeurig, hier hoort een hele programmering achter te komen.)
Verder, wanneer 2 (of meer) waarden "0" zijn, moet hij dit negeren. (dus wanneer 2 variabelen "0" zijn, en de rest van de variabelen allemaal verschillend zijn, zou hij de melding "tot ziens" moeten geven.

voorbeelden:
a == 1; b == 2; c == 3; d == 4; e == 5; f == 6; g == 7; h == 8; i == 9;
dan zou de melding moeten zijn: "tot ziens".
a == 0; b == 0; c == 3; d == 4; e == 5; f == 6; g == 7; h == 8; i == 9;
dan zou de melding moeten zijn: "tot ziens".
a == 1; b == 2; c == 3; d == 4; e == 5; f == 6; g == 7; h == 9; i == 9;
dan zou de melding moeten zijn: "goedendag".
a == 0; b == 0; c == 3; d == 4; e == 5; f == 6; g == 7; h == 9; i == 9;
dan zou de melding moeten zijn: "goedendag".

----------------------------------------------
Het zou zoiets moeten worden:

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

void main()
{
int a, b, c, d, e, f, g, h, i; //De variabelen

//De variabelen een willekeurig getal toekennen (van 0 t/m 9)
srand(time(0));
a = (rand() % 9); b = (rand() % 9); c = (rand() % 9);
d = (rand() % 9); e = (rand() % 9); f = (rand() % 9);
g = (rand() % 9); h = (rand() % 9); i = (rand() % 9);

//De If functie die jullie hopelijk voor mij kunnen verzinnen
If (<HIER ZOU HIJ MOETEN KOMEN>) { cout<<"goedendag\n"; }
Else { cout<<"tot ziens\n"; }

cin.get(); //Enter geven voordat het programma afsluit
}

(Dit is trouwens gewoon een voorbeeld, maar als hij hierin werkt, dan werkt hij ook in de programmering waarvoor hij bedoelt is.)
----------------------------------------------

Is hier een functie voor? en zo niet, wat is dan de makkelijkste manier om dit voor elkaar te krijgen?

(Ik weet wel hoe het ZOU kunnen, maar dan zou je alles met elkaar moeten gaan vergelijken, dus variabele a met de rest, dan b... dan c.... enz, dat zou dan wel erg veel werk zijn.)

sorteer de getallen.

overloop dan de lijst.
Als lijst(x) = lijst (x+1) en lijst (x) <>0 dan zet je een vlag.
klaar.

in Vb schrijf ik dat op 4 lijnen.

[Bericht gewijzigd door free_electron op (33%)]

Netter als je alle waarden in een matrix zet, bijv variabelen[9]. Zie je manual en google over hoe je matrices moet gebruiken. Dikke kans dat je een extra library moet includen.

Als je gebruik maakt van for-lussen scheelt het je veel programmeerwerk:


int variabelen[9], i, zerocount=0;

for(i=0; i<..; i=i+1)
{
 if(variabelen[i] == 0)
     zerocount=zerocount+1;
}

Nou weet je het aantal nullen. De tot ziens melding bij meer dan twee nullen is dan makkelijk te realiseren.
Hoe je dit voor de andere dingen maakt mag je zelf bekijken.

Als je wilt weten hoe vaak een getal voorkomt, en het bereik van die getallen voldoende klein is (zoals hier 0-9), kun je een bucket-sort gebruiken. Je maakt dan een array van 10 elementen waarin je bijhoudt hoeveel variabelen een bepaalde waarde hebben.

In pseudocode:


const NrVars = 9
const MaxValue = 9

array Vars[ NrVars ]
array Buckets[ MaxValue ]

<vul array Vars>
<zet hele array Buckets op 0>

for Count = 0 to NrVars
  Buckets[ Vars[ Count ] ] += 1

Naderhand hoef je alleen te zoeken of er in de array Buckets het getal 2 voorkomt

Op 6 mei 2009 01:45:25 schreef SparkyGSX:
Naderhand hoef je alleen te zoeken of er in de array Buckets het getal 2 voorkomt

Je bedoelt het getal 2 of groter. :)

whatever, ik neem aan dat de TS slim genoeg is om dat zelf te doen. Het gaat om het algoritme; op deze manier hoef je niet alle getallen onderling te vergelijken, maar het gaat dus alleen als het bereik klein genoeg is. Als de getallen bestaan uit 32-bit integers zonder verdere beperkingen, gaat dit niet echt werken natuurlijk. Naarmate het aantal getallen groter wordt t.o.v. het bereik, wordt het algoritme steeds efficiënter vergeleken met het onderling vergelijken van alle getallen.

Natuurlijk is het sorteren van de lijst, en daarna tellen hoe vaak hetzelfde getal achter elkaar voorkomt, ook een optie. Ik geloof dat q-sort in de standaard library zit.

de library qsort doet bubblesort als het aantal elementen klein is zoals hier.

Ok, dat wist ik niet. Quicksort kost wel erg veel geheugen bij grote lijsten, vooral als die om te beginnen al (bijna) helemaal gesorteerd zijn, omdat de boom dan erg ongebalanceerd is. Daarbij kost het meer tijd dan Bucketsort. Het is zeker niet zo dat Quicksort altijd de beste of snelste oplossing is, dat is afhankelijk van de omstandigheden. Het is aan de programmeur om die omstandigheden te beoordelen en de beste oplossing te kiezen. Ik heb wel eens een iteratieve Quicksort geïmplementeerd op een systeem met een zeer beperkte callstack.

De link met elektronica is... niet te vinden.