wie kann man beliebig viele Zahle einlesen?
-
Hallo Leute,
Ich bin ganz anfängerin und mit dem stoff bin ich erst bei Anweisungen und Fehlerbehandlung, also noch nicht bei array-s
das ist meine Aufgabestellung
Lesen Sie 2 Intervallgrenzen und danach beliebig viele Zahlen (Abschluss mit 0) ein, und geben Sie aus, wie viele Zahlen kleiner als die untere Intervallgrenze, wie viele im Intervall und wie viele größer als die obere Intervallgrenze waren.wie kann man beliebig viele zahle einlesen? und anschluss mit 0 heißt, dass ich 10, 20 usw einlesen soll ?
danke euch
Nata
-
nata schrieb:
anfängerin
Lesen Sie 2 Intervallgrenzen und danach beliebig viele Zahlen (Abschluss mit 0) ein, und geben Sie aus, wie viele Zahlen kleiner als die untere Intervallgrenze, wie viele im Intervall und wie viele größer als die obere Intervallgrenze waren
Ist doch nicht so schwer. Eine Schleife und ein paar
if-Anweisungen dürften genug sein.und anschluss mit 0 heißt, dass ich 10, 20 usw einlesen soll ?
Hä? Abschluss mit Null heißt, wenn Null eingegeben wird, dann wird die Eingabe beendet
Mein Ansatz wäre also
#include <iostream> #include <vector> #include <iterator> int main() { int int_min, int_max;//Variablen für die Intervalgrenzen std::cin >> int_min >> int_max;//Einlesen selbiger std::vector<int> numbers;//Ein STL-Container, der die Eingaben beinhalten wird. do numbers.push_back( *std::istream_iterator<int>(std::cin) ); //Diese Anweisung liest vom Eingabestream std::cin einen integer-Wert ein und legt diesen dann in unserem Container ab while(std::cin && numbers.back());//Das ganze passiert solange der Eingabestream in Ordnung ist (also eine Zahl korrekt eingelesen wurde) und die Zahl, die wir eingelesen haben, ungleich Null ist size_t under_int_min(0), //Hier definieren wir die Variablen die die Anzahl der verschiedenen Statusse der Eingaben beinhaltet in_int(0), above_int_max(0); std::vector<int>::iterator iter(numbers.begin());//Deklaration eines Iterators (in diesem Fall könnte es gar ein einfacher Zeiger sein) while(iter != numbers.end() - 1)//Solange der Iterator *nicht* auf das letzte Element im Container zeigt... (das letzte wird immer 0 sein ;) ) if(*++iter < int_min)///Hier der übliche Scheiss, wenn bla dann wird das inkrementiert usw. ++under_int_min; else if(*iter > int_max) ++above_int_max; else ++in_int; std::cout << "Under interval minimum: " << under_int_min << '\n' //Ausgabe << "Above interval maximum: " << above_int_max << '\n' << "In Interval: " << in_int << '\n'; }
-
ja ich bereite mich für eine Prüfung im Oktober.
wie kann man anderes beliebig viele zahle einlesen? Mit dem Stoff bin ich erst bei anweisungen
ich muss bis Oktober diese neveau erreichen, daher möchte ich schritt für schritt üben
praktische Prüfung
Aufgabe 1 [Programmierung]
Schreiben Sie eine Klasse Menge, die es erlaubt, mit eingeschr¨ankten, mathematischen Mengen zu arbeiten. Jede Menge
kann bis zu f¨unf unterschiedliche Integer-Werte enthalten. Wie f¨ur Mengen ¨ublich kann in einer Menge jeder Wert
h¨ochstens einmal enthalten sein. Folgende Methoden und Operationen m¨ussen implementiert werden:
• Methode bool add(int): Hinzuf¨ugen eines Wertes zu einer Menge. Die Methode soll false zur¨uckliefern, falls der
Wert nicht mehr eingetragen werden kann, weil schon f¨unf andere Werte in der Menge enthalten sind, true sonst.
• Operator +: Die Verkn¨upfung zweier Mengen mit + soll die Vereinigung der beiden Mengen als Ergebnis liefern.
Das heißt, die resultierende Menge enth¨alt genau alle Elemente, die in mindestens einer der beiden Mengen
enthalten sind. (Vorsicht: Werte d¨urfen auch in der Ergebnismenge nur h¨ochstens einmal enthalten sein.) Sollte
die Ergebnismenge mehr als f¨unf Werte enthalten, so ist als Ergebnis der Operation die leere Menge zu liefern.
• Methode Menge intersect(const Menge&) const : Liefert den Schnitt zweier Mengen. Dieser enth¨alt alle Elemente,
die in beiden Mengen enthalten sind.
Implementieren Sie die Klasse Menge mit den notwendigen Konstruktoren, Methoden und Operatoren, so dass jedenfalls
folgendes Beispielprogramm kompiliert, ausgef¨uhrt werden kann und die gew¨unschten Ergebnisse liefert.
int main() {
Menge a;
int values[]={1,2,3,4,5,6,7,8,9,10};
Menge b(values,3);
Menge c(values+1,4);
Menge d=b+c;
cout << a << b << c << d << endl;
if (d.add(3)) cout<<"3 OK" << endl;
if (d.add(7)) cout<<"7 OK" << endl;
a.add(10);
cout << a+b << b+d << a+b+d << endl;
cout << b.intersect(c) << endl;
int test[]={5,4,3,2};
Menge x(test,4);
cout << b.intersect(x) << endl;
cout << b << endl;
return 0;
}
Erwartete Ausgabe (da die Reihenfolge der Elemente einer Menge nicht definiert ist, d¨urfen Ihre Ergebnisse Abweichungen
in der Reihenfolge der ausgegebenen Werte innerhalb einer Menge aufweisen):
{}{1, 2, 3}{2, 3, 4, 5}{1, 2, 3, 4, 5}
3 OK
{10, 1, 2, 3}{1, 2, 3, 4, 5}{}
{2, 3}
{2, 3}
{1, 2, 3}
F¨ur Ihr Programm d¨urfen Sie nur iostream als include verwenden! Instanzvariablen sind private zu definieren! Interpretationsspielraum
in der Angabe k¨onnen Sie zu Ihren Gunsten nutzen.theoretische
**Aufgabe 1 [Rekursion]
Gegeben sind folgende Funktionen:
int g(int, int);
int f(int i, int j) {
if (i == 0) return j;
return g(i,j)+g(j,i);
}
int g(int i, int j) {
if (i%2 == 0) return f(i/2,j/2);
else return g(i-1,j-2);
}
Erstellen Sie den Aufrufgraphen f¨ur den Aufruf von f(5,3) und ermitteln Sie den Wert, den dieser Aufruf retourniert.Aufgabe 2 [Dynamische Objekte]
Die Klasse DynArray implementiert dynamische Arrays von Integer Werten. Ein dynamisches Array passt seine Gr¨oße
automatisch an die Anzahl der gespeicherten Werte an. Im konkreten Fall soll die Gr¨oße des Arrays zu Beginn auf
10 Elemente gesetzt und bei Bedarf verdoppelt werden. Also beim Einf¨ugen des 11. Elements wird das Array auf 20
Elemente vergr¨oßert, beim Einf¨ugen des 21. Elements auf 40 Elemente und so weiter.
Die Klassendeklaration lautet:
const int min_size=10; //Anfangsgroesse
class DynArray {
int count; //Anzahl der gespeicherten Werte
int size; //Aktuelle Groesse des Arrays
int vals; //Zeiger auf das Array, das die Werte enthaelt.
public:
DynArray(): count(0), size(min_size), vals(new int[size]) {}
~DynArray();
void add(int i);
};
a. Geben Sie eine Implementierung f¨ur die Funktion add an, die den Wert, der als Parameter ¨ubergeben wird, in
die n¨achste freie Position des Arrays eintr¨agt. Bei Bedarf muß die Gr¨oße des Arrays verdoppelt werden. (Da in
C++ die Gr¨oße von Arrays nicht ver¨andert werden kann, muß dazu ein neues Array der erforderlichen Gr¨oße
angelegt werden, die Werte aus dem urspr¨unglichen Array kopiert werden, und schließlich der Speicherplatz des
urspr¨unglichen Arrays freigegeben werden.)
b. Geben Sie eine Implementierung f¨ur den Destruktor an, der den durch das Array belegten Speicherplatz wieder
korrekt freigeben soll.*
-
nata schrieb:
wie kann man anderes beliebig viele zahle einlesen? Mit dem Stoff bin ich erst bei anweisungen
Da hab ich wohl definitiv zu tief in die Tasche gegriffen.
Ich seh mir das morgen Früh nochmal an. Hol dir am besten ein gutes Buch, das ist der schnellste und sicherste Weg um deine Prüfung zu bestehen.Aber Achtung! Nicht jedes Buch ist gut, lies dir den Bücherthread in der FAQ an (bin grad zu faul zum verlinken
).
-
Hab dir ein simpleres Beispiel geschrieben:
#include <iostream> //Standard Ein und Ausgabe using namespace std; //Wir verwenden den Standard-Namensraum int main() { int max = 0, min = 0; //Intervallgrenzen cout << "Geben sie bitte die Intervallgrenzen ein: "; cin >> min >> max; //Hier wird zuerst die untere, dann die obere Grenze eingelesen int number = 1 ; // Zahl, die eingelesen wurde //Zahlen, die Angeben wie viele Zahlen in, über oder unter den Intervallgrenzen sind int numbersAboveMax = 0, numbersUnderMin = 0, numbersInIntervall = 0; cout << "Geben sie die Zahlen ein: "; while (number != 0) //Wir lesen die Zahlen dann ein, wenn die eingelesene Zahl nicht Null ist { cin >> number; //Einlesen der Zahl if (number != 0) { if (number > max) //Wenn die Zahl goesser als die obere Intervallgrenze ist.. ++numbersAboveMax; //.. wird der Zähler für die zu großen Zahlen erhöht else if (number < min) //Sonst: Wenn die Zahl kleiner ist als die untere Intervallgrenze.. ++numbersUnderMin; //.. wird der Zähler für die zu kleinen Zahlen erhöht else //Wenn die Zahl nicht zu groß oder zu klein ist, muss sie richtig sein, und darum.. ++numbersInIntervall; // wird der Zähler für die richtigen Zahlen erhöht } } //Jetzt werden die Zähler ausgegeben cout << "Zahlen, die größer als der Angegebene Intervall sind: " << numbersAboveMax << '\n'; cout << "Zahlen, die kleiner als der Angegebene Intervall sind: " << numbersUnderMin << '\n'; cout << "Zahlen, die im Intervall liegen : " << numbersInIntervall << '\n'; }Die Idee ist, dass du in einer Schleife eine Zahle einliest und dann prüfst, ob sie größer, kleiner, richtig oder 0 ist.