C-Code Kleinste Zahl ausgeben

[Tobias (Gast)]

Guten Abend,
ich habe eine Frage. Ich muss für die Uni ein Programm schreiben bei dem 
der Anwender erst auswählt wie viele Zahlen er eingibt und dann diese 
eingibt. danach kann er wählen ob er die summe der zahlen möchte. Die 
größte Zahl. Die kleinste Zahl. Oder die zahlen nach der größe sortiert.

Bei mir funktioniert soweit alles nur wenn ich die kleinste Zahl 
ausgeben lassen will kommt immer 0 raus. Obwohl die 0 gar nicht mit 
eingegeben wurde.

Das mit dem sortieren habe ich nocht nicht.
Hier mein Code. Das mit dem Sortieren ist ab Zeile 52.

#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"


int main()
{
  int n = 0, anzahl = 0, max = 0, min = 0, a, i, b, *zahlen = NULL, summe = 0;
  printf("Wie viele Zahlen moechten Sie eingeben?\n");
  scanf_s("%d", &anzahl, 1);
  zahlen = (int *)calloc(anzahl, sizeof(int)); //Wir reservieren Speicher für "Anzahl" int-Werte mit calloc
  for (i = 0; i < anzahl; i++)
  {
    printf("Zahl eingeben: ", n + 1);
    scanf_s("%d", &a, 1);
    zahlen[n++] = a;
  }
  
  printf("\nFolgende Zahlen wurden eingegeben:\n");
  for (i = 0; i < n; i++)
  {
    printf("%d ", zahlen[i]);
    printf("\n");
  }

  printf("\nWaehlen Sie eine Anwendung:\nDruecken Sie 1 --> Summe aller Zahlen\nDruecken Sie 2 --> Groesste Zahl ausgeben\nDruecken Sie 3 --> Kleinste Zahl ausgeben\nDruecken Sie 4 --> Zahlen aufsteigend sortieren\n");
  scanf_s("%d", &b, 1);

  switch (b)
  {
  case 1:
    for (i = 0; i < anzahl; i++)
    {
      summe = summe + zahlen[i];
    }
    printf("Die Summe lautet:\n%d", summe);
    break;
  case 2:

    for (i = 0; i<anzahl; i++)
    {
      if (zahlen[i]>max)
      {
        max = zahlen[i];
      }
    }
    printf("Die groesste Zahl lautet %d", max);
    break;
  case 3:
    for (i = 1; i<anzahl; i++)
    {
      if (zahlen[i]<min)
      {
        min = zahlen[i];
      }
    }
    printf("Die kleinste Zahl lautet:\n%d\n", min);
  break;
  }


  system("pause");
  return 0;
}

Ich hoffe ihr könnt mir weiter helfen. Schon einmal Danke dafür. :)
Grüße

[Teo D. (teoderix)]

Tobias schrieb:
> Das mit dem sortieren habe ich nocht nicht.

Da sollte aber Deine Prio liegen, damit hast Du doch auch alles Andere!

[Hans Ulli K. (Gast)]

Ich gebe dir nur einen Tipp, weil alles andere schon die Lösung 
darstellen würde ...

Die Suche nach der größten Zahl ist schon mal richtig.
Obwohl eigentlich auch schon falsch, weil es werden nur positive Zahlen 
genommen.
Nur leider ist die Suche nach der kleinesten Zahl falsch und das nur ein 
einer Stelle.

Der Rest steht glaube ich in K&R

[Tobias (Gast)]

Für das sortieren kann ich ja einen Bubble sort verwenden?
Gibt es eine Seite wo das gut erklärt wird. Ich habe nämlich keine 
Ahnung ie ich diesen anwenden muss...

Gruß

[OldMan (Gast)]

Tobias schrieb:
> max = 0, min = 0, a,


Tobias schrieb:
> case 3:
>     for (i = 1; i<anzahl; i++)
>     {
>       if (zahlen[i]<min)
>       {
>         min = zahlen[i];
>       }
>     }

min ist mit 0 initialisiert. Somit ist das Ergebnis immer 0!
Ausserdem beginnt Deine for-Schleife mit dem Index 1 und nicht 0, wie
es sein sollte.

Jetzt sollte bei Dir der Groschen fallen.....

[Tobias (Gast)]

Ja das mit der initialisierung hatte ich auch schon im Kopf. Aber ich 
muss min ja irgendeinen wert zuweisen. Wie mache ich es das es nicht 0 
ist?

[Hans Ulli K. (Gast)]

OldMan schrieb:
> Tobias schrieb:
>> max = 0, min = 0, a,
>
>
> Tobias schrieb:
>> case 3:
>>     for (i = 1; i<anzahl; i++)
>>     {
>>       if (zahlen[i]<min)
>>       {
>>         min = zahlen[i];
>>       }
>>     }
>
> Ausserdem beginnt Deine for-Schleife mit dem Index 1 und nicht 0, wie
> es sein sollte.

Dann schau dir mal calloc an. Da werden "anzahl" Elemente alloziert.

In C zählt man immer von 0

Und für die Initierlasierung gibt es "vordefinierte" defines

Alles andere in nicht portabel

[chris (Gast)]

Tobias schrieb:
> Wie mache ich es das es nicht 0
> ist?

Indem du es nicht mit 0 initialisierst, sondern mit dem maximal 
auftretenden Wert. Dann findest du auf jeden Fall eine Zahl, die kleiner 
ist.
D.h. je nach Architektur ist ein int 16, 32 oder 64bit breit. Am PC 
wahrscheinlich 32bit, also Wertebereich -2147483648..2147483647

--> init mit 2147483647

[Hans Ulli K. (Gast)]

#include <limits.h>

[Tobias (Gast)]

Hans Ulli Kroll schrieb:
> #include <limits.h>

Was meinst du damit?


Und zu chris: Habe das gerade so getestet dann kommt aber immer noch 0 
raus. Kann mir vielleicht jemand ne Lösung präsentieren. Ich mach schon 
ewig rum...

Grüße

[Matthias (Gast)]

Hans Ulli Kroll schrieb:
> In C zählt man immer von 0

In dem Fall macht es aber Sinn, mit 1 zu beginnen:

   min = zahlen[0];
   for (i = 1; i<anzahl; i++)
      ...

[Tobias (Gast)]

Matthias schrieb:
> Hans Ulli Kroll schrieb:
>> In C zählt man immer von 0
>
> In dem Fall macht es aber Sinn, mit 1 zu beginnen:   min = zahlen[0];
>    for (i = 1; i<anzahl; i++)
>       ...

so:

    min = zahlen[0];
    for (i = 1; i<anzahl; i++)
    {
      if (zahlen[i]<min)
      {
        min = zahlen[i];
      }
    }


??

[Matthias (Gast)]

Ja, so. Du musst jetzt jedoch überprüfen, ob anzahl==0 (ist das in der 
Aufgabe zulässig?)

[PVA (Gast)]

Initialisiere min doch einfach mit zahlen[0].

[PVA (Gast)]

Oh...zu spät ;-)

[Tobias (Gast)]

In der Aufgabe ist alles zulässig ;)
In wie fern meinst du die Überprüfung?
Die Anzahl ist nie Null, da der Anwender ja eine bestimmte anzahl an 
zahlen eingibt.
anzahl ist dann zum beispiel 2 oder 10 oder 15 oder 20...

[Tobias (Gast)]

PVA schrieb:
> Initialisiere min doch einfach mit zahlen[0].

Das funktioniert trotdem nicht. Es kommt immer noch  0 raus. Hier mal 
mein aktueller stand:

  case 3:
    min = zahlen[0];
    for (i = 1; i<anzahl; i++)
    {
      if (zahlen[i]<min)
      {
        min = zahlen[i];
      }
    }
    printf("Die kleinste Zahl lautet:\n%d\n", min);
  break;

[kann kein c (Gast)]

Tobias schrieb:
> int n = 0, anzahl = 0, max = 0, min = 0, a, i, b, *zahlen = NULL,
> summe = 0;

besser
int n = 0, anzahl = 0, max = 0, min = maxint, a, i, b, *zahlen = NULL,
 summe = 0;

[Martin H. (Gast)]

Warum machst du es dir so schwer? Du brauchst nur eine Funktion 
wirklich, nämlich die Sortierung. Danach nimmst du einfach entweder das 
erste oder das letzte Element oder du gibst alle aus. Fertig.

[Tobias (Gast)]

Martin H. schrieb:
> Warum machst du es dir so schwer? Du brauchst nur eine Funktion
> wirklich, nämlich die Sortierung. Danach nimmst du einfach entweder das
> erste oder das letzte Element oder du gibst alle aus. Fertig.

Die Sortierung bekomm ich nicht hin...

[Joe F. (easylife)]

http://stackoverflow.com/questions/1787996/c-library-function-to-do-sort

#include <stdio.h>
#include <stdlib.h>
int comp (const void * elem1, const void * elem2) 
{
    int f = *((int*)elem1);
    int s = *((int*)elem2);
    if (f > s) return  1;
    if (f < s) return -1;
    return 0;
}
int main(int argc, char* argv[]) 
{
    int x[] = {4,5,2,3,1,0,9,8,6,7};

    qsort (x, sizeof(x)/sizeof(*x), sizeof(*x), comp);

    for (int i = 0 ; i < 10 ; i++)
        printf ("%d ", x[i]);

    return 0;
}

[Karl H. (kbuchegg)]

Tobias schrieb:
> PVA schrieb:
>> Initialisiere min doch einfach mit zahlen[0].
>
> Das funktioniert trotdem nicht.

Doch, das funktioniert.

> Es kommt immer noch  0 raus. Hier mal
> mein aktueller stand:

Hast du den auch compiliert?
Hat es beim compilieren Fehler gegeben?

[Karl H. (kbuchegg)]

Joe F. schrieb:
> http://stackoverflow.com/questions/1787996/c-library-function-to-do-sort
> ##


Joe.
Deine Bemühungen in allen Ehren.

Aber der Zweck der Übung ist NICHT eine besonders clevere oder elegante 
Lösung zu finden. Der Zweck solcher Übungsbeispiele ist es, Übung im 
Umgang mit Arrays zu bekommen.

Klar. Draussen in der Industrie würde man das so machen. Ganz im 
Gegenteil. Aber das hier ist nicht Industrie. Das ist Uni und ein 
Übungsbeispiel für Anfänger, der gerade mal eine Handvoll C 
Schlüsselwörter kennt (von beherrschen reden wir erst mal nicht)

[Rolf M. (rmagnus)]

Es gibt in C bereits eine Standardfunktion namens qsort(), die das 
Sortieren für dich übernehmen kann.

[Tobias (Gast)]

Also ich habe jetzt gerade ein Mit-studenten gefragt wegen dem bubbel 
sort. Hab das soweit hinbekommen. Und die Ausgabe dann wieder mit einer 
for-schleife.
Danach ist das mit dem Min, und Max wirklich easy. Muss man ja nur 
zahlen[0] und zahlen [anzahl-1] ausgeben und schon hat man die werte.

Ich danke euch für die Bemühungen.

:)

[Norbert Windmann (Gast)]

Im Studium sollte man aber eine Sortierroutine ohne Sortierfunktion 
aufschreiben können - nein, sogar mehr als eine. Das gehört eigentlich 
zum Grundwissen.

[DirkB (Gast)]

Tobias schrieb:
> Danach ist das mit dem Min, und Max wirklich easy. Muss man ja nur
> zahlen[0] und zahlen [anzahl-1] ausgeben und schon hat man die werte.

Beim Sortieren musst du mehrmals durch das Array laufen.
Summe, Min und Max kannst du zusammen bei einem Durchlauf ermitteln.

[Diek (Gast)]

Rolf Magnus schrieb:
> Es gibt in C bereits eine Standardfunktion namens qsort(), die das
> Sortieren für dich übernehmen kann.

Das hört sich für mich aber sehr nach Qt an und das wär dann C++ ;)

[operator (Gast)]

Schlimmer als Threadersteller die nicht selber die suchfunktion 
benützen, sind eigentlich nur Antworter, die ins blaue raten und 
unwissende verwirren.
Qsort: "qsort is a C standard library function that implements..."
http://en.wikipedia.org/wiki/Qsort

[MagnusGehHeim (Gast)]

Rolf Magnus schrieb:
> Es gibt in C bereits eine Standardfunktion namens qsort(), die das
> Sortieren für dich übernehmen kann.

Super, das ist dann sicher eine tolle Übung um C zu lernen.

[Markus F. (mfro)]

MagnusGehHeim schrieb:
> Super, das ist dann sicher eine tolle Übung um C zu lernen.

Lernen wird heutzutage allgemein überschätzt.

Es reicht doch, wenn man "Wikipedia" tippen kann.

[Thomas (Gast)]

Was für eine Uni ist denn das? Das sieht mir doch eher nach Berufschule 
für Fachinformatiker aus.
Bei uns hätte man einfach stillschweigend vorausgesetzt, dass man sowas 
triviales kann, allenfalls hätte man uns als Aufwärmübung gegeben, 
Quicksort oder Heapsort zu programmieren.
Keine Provokation, die Frage ist Ernst gemeint.
Th.

[Daniel A. (daniel-a)]

Tobias schrieb:
> Hans Ulli Kroll schrieb:
>> #include <limits.h>
>
> Was meinst du damit?

Tobias schrieb:
> int n = 0, anzahl = 0, max = 0, min = 0, a, i, b, *zahlen = NULL,
> summe = 0;

Das bezog sich darauf, dass in limits.h der grösste int Wert als macro 
definiert wurde, und man diesen min zuweisen könnte. Dafür bevorzuge ich 
volgende macros:

#define MIN(T) ((~(T)0)>0?0:(((T)1)<<(sizeof(T)*8-1))) 
#define MAX(T) ((~(T)0)>0?(~(T)0):(~MIN(T)))

Da sie mir das Suchen in der limits.h nach dem entsprechenden makro 
ersparen.

Ein Beispiel zu den Macros ist im Anhang.

PS: Das Makro ist nicht auf Bitfields anwendbar, lässt sich jedoch bei 
bedarf einfach modifizieren.

[Hans Ulli K. (Gast)]

Daniel A. schrieb:
> Tobias schrieb:
>> Hans Ulli Kroll schrieb:
>>> #include <limits.h>
>>
>> Was meinst du damit?
>
> Tobias schrieb:
>> int n = 0, anzahl = 0, max = 0, min = 0, a, i, b, *zahlen = NULL,
>> summe = 0;
>
> Das bezog sich darauf, dass in limits.h der grösste int Wert als macro
> definiert wurde, und man diesen min zuweisen könnte. Dafür bevorzuge ich
> volgende macros:
>
>

> #define MIN(T) ((~(T)0)>0?0:(((T)1)<<(sizeof(T)*8-1)))
> #define MAX(T) ((~(T)0)>0?(~(T)0):(~MIN(T)))
>

>
> Da sie mir das Suchen in der limits.h nach dem entsprechenden makro
> ersparen.

Für dich ist das zwar gut, aber richtig ist es nicht
Was machst du, wenn irgendwo in den Headerfiles

#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))

auftaucht. Und das ist nicht selten ...

Joe F. schrieb:
> http://stackoverflow.com/questions/1787996/c-library-function-to-do-sort
>
Hoffentlich ist das Array nicht schon sortiert ...

[Daniel A. (daniel-a)]

Hans Ulli Kroll schrieb:
> Für dich ist das zwar gut, aber richtig ist es nicht
> Was machst du, wenn irgendwo in den Headerfiles

#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))

> auftaucht. Und das ist nicht selten ...

Ok. Der Name war ungünstig gewählt, können wir uns auf TMAX und TMIN 
einigen? Oder gibt es weitere Namensvorschläge?

[Hans Ulli K. (Gast)]

Es ist Allgemeinen so, dass man eigene Symbole meistens mit einem oder 
zwei Unterstriche beginnt
also
#define _MIN()
#define __MIN()

[Daniel A. (daniel-a)]

Hans Ulli Kroll schrieb:
> Es ist Allgemeinen so, dass man eigene Symbole meistens mit einem oder
> zwei Unterstriche beginnt

Sind die nicht schon für den compiler reserviert? Ich hatte da mal 
riesen Probleme beim undefinieren eines macros, finde den thread leider 
nichtmehr...

Ausserdem generieren macros doch garkeine Symbole, und wenn alle 
unterstriche für ihre Makros verwenden löst dass das 
Namenskolisionsproblem auch nichtmehr.

Ich denke, ein Prefix als Namespace könnte die Lösung sein.

[Dirk B. (dirkb2)]

Daniel A. schrieb:
> der grösste int Wert als macro
> definiert wurde, und man diesen min zuweisen könnte

Das universellste ist immer noch, min und max mit dem ersten Wert 
aus dem Array zu initialisieren.

Da braucht man sich keine Gedanken um den Datentyp zu machen.

[Karl H. (kbuchegg)]

Daniel A. schrieb:
> Hans Ulli Kroll schrieb:
>> Für dich ist das zwar gut, aber richtig ist es nicht
>> Was machst du, wenn irgendwo in den Headerfiles
>

> #define MIN(x, y) (((x) < (y)) ? (x) : (y))
> #define MAX(x, y) (((x) > (y)) ? (x) : (y))
>

>> auftaucht. Und das ist nicht selten ...
>
> Ok. Der Name war ungünstig gewählt, können wir uns auf TMAX und TMIN
> einigen? Oder gibt es weitere Namensvorschläge?

Die Frage ist doch, warum nicht die Makros aus limit.h nehmen?
Ob du jetzt eigene Makros benutzt oder die aus limits.h - merken musst 
du dir die Makronamen sowieso. Da kannst du dir auch gleich die aus 
limits.h merken.

Das ist ungefähr so, wie man sich natürlich eigene typedefs für einen 
Datentyp mit bestimmten Bitzahlen machen kann. Man kann aber auch ganz 
einfach die aus stdint.h nehmen. Das eine ist so gut wie das andere. Nur 
das es die aus stdint.h auf jedem C System gibt und die vom 
Compilerhersteller schon für dich angepasst wurden.

[spontan (Gast)]

@tobias:  Was studierst Du eigentlich?

[Route_66 (Gast)]

Hallo!

Tobias schrieb:
> Die Anzahl ist nie Null, da der Anwender ja eine bestimmte anzahl an
> zahlen eingibt.

Tipp:
Das ist ganz schlechter Programmierstil. User-Eingaben müssen IMMER 
auf Zulässigkeit, Plausibilität und Bereichsüberschreitung geprüft 
werden. Diesen Grundsatz muss man von Anfang an beherzigen.

[Dirk B. (dirkb2)]

Daniel A. schrieb:
> Dafür bevorzuge ich
> volgende macros:

Diese Makros schränken die Portabilität von C ein.
Du gehst von Zweierkomplement und CHAR_BIT == 8 aus.

[Daniel A. (daniel-a)]

Karl Heinz schrieb:
> Die Frage ist doch, warum nicht die Makros aus limit.h nehmen?

limits.h hat für jeden Datentyp 2 makros, exclusive benutzerdefinierter 
Datentypen.
Ich habe 2 makros für alle Integer datentypen, inklusive 
benutzerdefinierte.

Eine einfache rechnung:

n = anzahl datentypen, für die limits.h makros hat
wobei gilt: ∞ > n > 1 und  n ∈ N
Anzahl Makros MIN/MAX macros von limits.h: 2n
Anzahl meiner makros: 2
Schlussfolgerung: 
  2n - 2 = Weniger zu merkende makros
  n = Anzahl unterstützte integertypen von limit.h
  ∞ = Anzahl von meinem makro Unterstützten typen

> Ob du jetzt eigene Makros benutzt oder die aus limits.h - merken musst
> du dir die Makronamen sowieso. Da kannst du dir auch gleich die aus
> limits.h merken.

Das sind aber viel mehr Makros! Und nicht jeder Integer datentyp (z.B. 
benutzerdefinierte) sind abgedekt.

[Daniel A. (daniel-a)]

Dirk B. schrieb:
> Diese Makros schränken die Portabilität von C ein.
> Du gehst von Zweierkomplement und CHAR_BIT == 8 aus.

#define MIN(T) ((~(T)0)>0?0:(((T)1)<<(sizeof(T)*CHAR_BIT-1)

Damit bleibt nurnoch dass Zweierkomplement-Problem, welches ich nicht in 
einem Makro lösen kann.

Ich werde mir eine C++ universallösung mit templates ausdenken, die 
immer funltioniert.

[Daniel A. (daniel-a)]

Daniel A. schrieb:
> Ich werde mir eine C++ universallösung mit templates ausdenken, die
> immer funktioniert.

Hat ne weile gedauert, folgendes ist zwar vollkommen unbrauchbar, würde 
aber immer funktionieren. Mit c++11, gcc 4.8.3, char und short 
Datentypen getestet. Grössere Datentypen füren zu einem Stack Overflow 
während dem Kompilieren. Eine äquivalente Lösung ohne C++11 zur 
Compiletime ist theoretisch möglich, praktisch aber nicht 
funktionsfähig.

template<typename T>
class IntInfo {
private:
  static constexpr T calc_min(T x=0){
    return ((T)(x-1)<x)?calc_min((T)(x-1)):x;
  }

  static constexpr T calc_max(T x=0){
    return ((T)(x+1)>x)?calc_max((T)(x+1)):x;
  }
public:
  static constexpr T min = calc_min();
  static constexpr T max = calc_max();
};

int main(){
  std::cout << (int)IntInfo<char>::min << std::endl;
  std::cout << (int)IntInfo<char>::max << std::endl;
  std::cout << IntInfo<short>::min << std::endl;
  std::cout << IntInfo<short>::max << std::endl;
  std::cout << IntInfo<unsigned short>::min << std::endl;
  std::cout << IntInfo<unsigned short>::max << std::endl;
}

Jetzt besteht noch die Möglichkeit die Werte mit einer Formel ohne 
Zuhilfenahme des Datentyps direkt zu berechnen.

[Hans Ulli K. (Gast)]

Vor 30 Jahren konntest du den Code dort

http://www.ioccc.org/

einreichen und vielleicht einen Preis gewinnen :-)
Leider ist der C++ ...

[Markus F. (mfro)]

Hans Ulli Kroll schrieb:
> Vor 30 Jahren konntest du den Code dort
>
> http://www.ioccc.org/
>
> einreichen und vielleicht einen Preis gewinnen :-)
> Leider ist der C++ ...

Ich verstehe das als "ist mir zu kompliziert"?

Find' ich nämlich nicht, ich find's sogar sehr elegant. Rekursive 
Template-Metaprogramme. Respekt für die Idee!

Bloß: wenn's nicht funktioniert, ist's auch nicht sehr viel wert ;).