Nach kleinsten Wert in einer Tabelle suchen



  • Guten Abend,

    habe folgenes Problem:

    ich habe mit einer While Schleife in der eine Schrittweite inkrementiert wird,
    eine Tabelle erstellt. Ein Wert innerhalb der Tabelle wird bei einer bestimmten
    Schrittweite am kleinsten.
    Diesen Wert würde ich gerne haben um Ihn unterhalb der Tabelle nochmal anzeigen zu lassen.
    Gibs dafür irgendwie eine Funktion oder ähnliches um diesen Wert zu bekommen?

    Hier anbei der Code der die Tabelle erstellt, Liebe Grüße und einen schönen Sonntag Abend.

    #ifdef _MSC_VER
    #define _CRT_SECURE_NO_WARNINGS
    #endif
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    double atof(char s[]);
    
    void main()
    {
    	//Definition der Variablen
    
    	int i, flag;
    	char x[1000];
    	char xMax[1000];
    	char xMin[1000];
    	float x1=0, y1=-20; //Koordinaten Punkt A
    	float x2=50, y2=30; //Koordinaten Punkt B
    	float y3=0; //Koordinaten Punkt P
    	float v1 = 3, v2 = 1.5; //Geschwindigkeit Land, Wasser
    	float s1, s2, ssum; //Weg A nach P, Weg B nach P
    	float t1, t2, tsum; //Zeit für Weg s1, s2
    	float zw; //zwischenwert für inkrementierung von x
    	char temp;
    
    	//Eingabedialog
    
    	do{
    		flag = 0;
    		printf("Bitte den kleinsten X-Wert eingeben:");
    		gets(xMin);
    		for (i = 0; i < strlen(xMin); i++)
    		if (!((xMin[i] >= 48 && xMin[i] <= 57) || xMin[i] == 46)){
    			flag = 1;
    			break;
    		}
    	} while (flag);
    	do
    	{
    		flag = 0;
    		printf("Bitte den groessten X-Wert eingeben:");
    		gets(xMax);
    		for (i = 0; i < strlen(xMax); i++)
    		if (!((xMax[i] >= 48 && xMax[i] <= 57) || xMax[i] == 46)){
    			flag = 1;
    			break;
    		}
    	} while (flag);
    		do{
    			flag = 0;
    			printf("Bitte die Schrittweite eingeben:");
    			gets(x);
    			for (i = 0; i < strlen(x); i++)
    			if (!((x[i] >= 48 && x[i] <= 57) || x[i] == 46)){
    				flag = 1;
    				break;
    			}
    		} while (flag);
    		if (atof(xMax)>atof(xMin) && atof(x) <= atof(xMax) - atof(xMin)){
    			printf("%f\n%f\n%f\n", atof(xMin), atof(xMax), atof(x));
    			//Ausagbe des Tabellenkopfes
    
    			printf("\n\n--------------------------------------------------------------------------------");
    			printf("\n\tx[m]\tA[m]\tA[sec]\tB[m]\tB[sec]\tWeg[m]\tZeit[sec]\n--------------------------------------------------------------------------------\n");
    			//Berechnung
    			zw = atof(xMin) - atof(x);
    			while (zw <= atof(xMax))
    			{
    				zw = zw + atof(x);
    				s1 = sqrt((x1 + zw)*(x1 + zw) + y1*y1);
    				s2 = sqrt((x2 - zw)*(x2 - zw) + y2*y2);
    				t1 = s1 / v1;
    				t2 = s2 / v2;
    				tsum = t1 + t2;
    				ssum = s1 + s2;
    				printf("\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n", zw, s1, t1, s2, t2, ssum, tsum);
    			}
    			//Kontrollausgabe
    			printf("\nx=Schrittweite\n");
    		}
    		else
    		{
    			printf("\n\nDer Maximale X-Wert muss groesser als der minimale X-Wert sein!\nDie Schrittweite muss kleiner als der Abstand zwischen\nden Intervallgrenzen sein!\n\n");
    		}
    	system("Pause");
    	return 0;
    }
    
    double atof(char s[])
    {
    	double val = 0, power;
    	int  sign = 1, i;
    	// Unerwünschte Zeichen in den Müll
    	for (i = 0; s[i] == ' ' || s[i] == '\t' || s[i] == '\n'; i++);
    	// Vorzeichen erkennen und sign setzen 1 und (-1)
    	if (s[i] == '+' || s[i] == '-')
    		sign = (s[i++] == '-') ? -1 : 1;
    	// Ziffernweite in eine gemeinsame Variable val speichern
    	for (val = 0; s[i] >= '0' && s[i] <= '9'; i++)
    		val = val * 10 + s[i] - '0';
    	// Komma und Punkt erkennen
    	if (s[i] == '.' || s[i] == ',')
    		i++;
    	// Nachkommastellen auf val Addieren
    	for (power = 1; s[i] >= '0' && s[i] <= '9'; i++){
    		val = val * 10 + s[i] - '0';
    		power *= 10;
    	}
    	return  (sign * val / power);
    } /* atof() */
    


  • atof gibt es bereits in der Standardbibliothek, sowas nochmal selbst zu versuchen, ist Unsinn.



  • du benutzt drei mal den code

    flag=0;    
    for (i = 0; i < strlen(xMin); i++)
            if (!((xMin[i] >= 48 && xMin[i] <= 57) || xMin[i] == 46)){
                flag = 1;
                break;
            }
    

    nur dass du eben mal xMin, mal xMax und mal x eingibst.
    stattdessen kannst du auch eine funktion schreiben, die das selbe bewirkt.
    z.b. kannst du sie fehler nennen. als parametet übergibst du dein char-array und als rückgabe soll sie dir entweder 1 (wenn falsche zeichen im array sind) oder 0 (wenn alles richtig ist) zurückgeben.
    statt dem oberen code würdest du dann z.b. schreiben:

    flag = fehler(xMin);
    

    oder gleich in die while bedingung:

    do{
            printf("Bitte den kleinsten X-Wert eingeben:");
            gets(xMin);
           } while (fehler(xMin));
    

    Funktionen erhöhen meist die übersichtlichkeit im code.
    außerdem könntest du auch statt

    >= 48
    

    auch

    >='0'
    

    schreiben. dann musst man nicht extra in die ascii-tabelle schauen um zu sehen, worauf du prüfst.

    um den kleinsten wert herauszufinden fällt mir keine funktion ein. bin aber selbst auch noch nicht so bewandert in C.
    so könnte es aber auch gehen:

    float kleinste=0;    //neue variable oben
    // dann deine abfragen
    // beginn schleife mit berechnungen
    
    ssum = s1 + s2;
    
    if (kleinste == 0)
        kleinste = ssum;
    else if (kleinste > ssum)
        kleinste = ssum;
    
    // rest der schleife
    
    printf("%f", kleinste);
    

    lg bluebird

    Edit: du hast math.h eingebunden. warum benutzt du dann nicht

    pow(x1 + zw, 2)
    

    statt

    (x1 + zw)*(x1 + zw)
    

    ?



  • Vielen Dank für diese konstruktiven anstöße bluebird. 🙂
    werde sie gleich in die Tat umsetzen um mein programm besser zu gestalten.

    habe heute in der hochschule bereits anregungen zum ausgeben des kleinsten werts
    bekommen. Also habe quasi deinen Tipp schon in die Tat umgesetzt 😉


Anmelden zum Antworten