API tools faq
paste
Advertisement
Guest User

Krasses HUE Copyright Niklatze

a guest
Apr 24th, 2018
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.26 KB | None | 0 0
raw download clone embed print report
  1. //Preprozessor-Anweisungen
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <strings.h>
  5. #include <unistd.h>
  6.  
  7. /*
  8.   Name: Niklas Martin Haiden
  9.   Klasse / Katalognr.: 1BHIF / 8
  10.   Aufnahmenummer: 20170023
  11.   Abgabe-Datum: 26.4.2018
  12.   Programmname: POSHÜ_6_HAIDEN
  13.   --------------------------------------------------------
  14.   Beschreibung:
  15.   Es ist ein Programm zu schreiben, durch welches der User Datenwerte
  16.   einlesen kann und durch verschiedene Kommandos statistisch auswerten kann.
  17. */
  18.  
  19. ///Defines & andere Preprozessor-Befehle
  20. ///****************************************************
  21. #define gross 50  ///<-- Größe des f & fcopy Arrays
  22. ///****************************************************
  23.  
  24. ///====================================================================================
  25. ///Funktionsprototypen
  26. ///====================================================================================
  27. void displayIntArr(const int *f, size_t n);
  28. void deletedata(int *f, size_t n);
  29. int spberechnung(const int *f, size_t n);
  30. void werteEinlesen(int *f, int *weing);
  31. void sortfeld(int *f, size_t n);
  32. void copyfeld(const int *f, int *fcopy, size_t n);
  33. void sortedanzeigen(const int *f, size_t n);
  34. void wait();
  35. void help();
  36. void fehlermeldung(int fehlerwert);
  37. double calcarithm(int *f, size_t n);
  38. int modalwert(const int *f, size_t n, int *modal);
  39. double median(const int *f, size_t n);///===================================================================================
  40.  
  41.  
  42. /********************************************************
  43. Funktionsname: main
  44. =======================================================
  45. Zweck: Stellt die Auswahl sowie die Funktionsaufrufe
  46.        bereit
  47. =======================================================
  48. Variablen / Felder:
  49.             f[gross]: Hier werden die Daten gespeichert
  50.  
  51.             userw[50]: Größe des Arrays, wo die Befehle,
  52.             die der User, absetzt gespeichert werden
  53.             int userwadd
  54.  
  55.             quit: Variable die speichert, wie lange
  56.             der User das Programm ausführen möchte.
  57.             Möchte der User aufhören, wird es auf 0
  58.             gesetzt.
  59.  
  60.             weing: Wieviele Werte eingegeben wurden
  61.  
  62.             ueing: Für die Eingabe, wieviele Buchstaben
  63.             der User eingegeben hat.
  64.  
  65.             modal: Modalwert
  66.  
  67. =======================================================
  68. Return-Wert: 0 : alles ist glatt gelaufen
  69. *******************************************************
  70. */
  71. int main() {
  72.     int f[gross];   //Feld in dem die Daten gespeichert werden
  73.     char userw[50];      //Wahl des Users
  74.     int quit = 1;       //Ist der User fertig, wird es auf 0 gesetzt
  75.     int weing = 0;        //Wieviele mal eingegeben Werte eingegeben wurde
  76.     int ueing;       //Wieviele Buchstaben hat der User eingegeben, für Befehleauswahl
  77.     int modal;
  78.     int retarn;
  79.  
  80.     printf("\n\tWillkommen. Befehle mit ? auflisten.\n");//Willkommens-Nachricht
  81.     do {
  82.         printf("\n\t> ");                                     //Eingabeprompt
  83.         ueing = sscanf(gets(userw), "%c%c", &userw[0], &userw[1]); //Einlesen
  84.  
  85.         if(ueing == 1) {
  86.             switch(userw[0]) {
  87.             case '?':
  88.                 help();  //Aufrufen der Help-Funktion
  89.                 wait();
  90.                 break;
  91.  
  92.             case 'n':
  93.                 werteEinlesen(f, &weing);
  94.                 system("cls");
  95.                 break;
  96.  
  97.             case 'o':
  98.                 if(weing > 0) {
  99.                 printf("\n\tSortiert: \n");
  100.                 sortedanzeigen(f, weing);
  101.                 }
  102.                 else puts("\n\tEs gibt noch keine Werte.\n");
  103.                 break;
  104.             case 's':
  105.  
  106.                 if(weing > 0) {
  107.                         puts("\n\tUnsortiert:");
  108.                         displayIntArr(f, weing);
  109.                 }
  110.                 else puts("\n\tEs gibt noch keine Werte.\n");
  111.  
  112.                 break;
  113.             case 'd':
  114.                 weing = 0; //Setzen der eingegeben Werte auf 0
  115.                 printf("\n\tWerte geloescht.\n");
  116.                 wait();
  117.                 system("cls");
  118.                 break;
  119.             case 'q':
  120.                 printf("\n\tAuf Wiedersehen!\n");
  121.                 wait();
  122.                 quit = 0;
  123.                 break;
  124.             default:
  125.                 system("cls");
  126.                 fehlermeldung(3);
  127.                 wait();
  128.                 break;
  129.             }
  130.         }
  131.         if(ueing == 2) {
  132.             if(userw[0] == 's' && userw[1] == 'p') {
  133.                 printf("\n\tSpannweite: %d\n", spberechnung(f, weing));
  134.                 wait();
  135.             } else if(userw[0] == 'm' && userw[1] == 'e') {
  136.  
  137.                 printf("\n\tMedian: %.3lf\n", median(f, weing));
  138.  
  139.             } else if(userw[0] == 'm'  && userw[1] == 'o') {
  140.                 system("cls");
  141.                 retarn = modalwert(f, weing, &modal);
  142.                 if(retarn == 1) {
  143.                     printf("\n\tModalwert: %d", modal);
  144.                 } else {
  145.                     printf("\n\tModalwert nicht eindeutig.\n");
  146.                 }
  147.             } else {
  148.                 fehlermeldung(3);
  149.             }
  150.  
  151.         }
  152.         }while(quit);
  153.          return 0;
  154.     }
  155.  
  156. /******************************************************
  157. Funktionsname: wait
  158. =======================================================
  159. Zweck: Wartet bis der User bereit ist
  160. =======================================================
  161. Variablen / Felder:
  162.                    wait: Wird für getch benötigt,
  163.                    hat keine weitere Funktion.
  164. =======================================================
  165. Return-Wert: keinen
  166. *******************************************************
  167. */
  168. void wait() {
  169.     char wait;
  170.     wait = getch();
  171.     system("cls");
  172. }
  173. /******************************************************
  174. Funktionsname: fehlermeldung
  175. =======================================================
  176. Zweck: Zeigt eine Fehlermeldung an,
  177.        basierend auf Fehlerwert
  178. =======================================================
  179. Variablen / Felder:
  180.                    fehlerwert: Wert der von dem
  181.                    Fehlerverursacher übergeben wird,
  182.                    basierend danach wird angezeigt
  183. =======================================================
  184. Return-Wert: keinen
  185. *******************************************************
  186. */
  187. void fehlermeldung(int fehlerwert) {
  188.     switch(fehlerwert) {
  189.     case 1:
  190.         system("cls");
  191.         printf("\n\tArray ist bereits voll befuellt.\t");
  192.         wait();
  193.         break;
  194.     case 2:
  195.         system("cls");
  196.         printf("\n\tEingabefehler. Bitte wiederholen.\n");
  197.         wait();
  198.         break;
  199.     case 3:
  200.         printf("\n\tDieses Kommando existiert nicht.\n");
  201.         wait();
  202.         break;
  203.  
  204.     }
  205.  
  206.  
  207. }
  208. /******************************************************
  209. Funktionsname: help
  210. =======================================================
  211. Zweck: Zeigt den Hilfe-Text an
  212. =======================================================
  213. Variablen / Felder: -
  214. =======================================================
  215. Return-Wert: keinen
  216. *******************************************************
  217. */
  218. void help() {
  219.     system("cls"); //Clearen des Bildschirms für bessere Lesbarkeit
  220.  
  221.     //Ausgabe des Help-Textes
  222.     printf("\n\t> n       (Einen) neuen Wert eingeben, welcher an die Datenreihe angehaengt wird.\n");
  223.     printf("\t> s       Datenreihe in der originalen Reihenfolge anzeigen lassen\n");
  224.     printf("\t> o       Dateienreihe in aufsteigend sortierter Reihenfolge anzeigen lassen\n");
  225.     printf("\t> d       Alle Werte in der Dateinreihe loeschen\n");
  226.     printf("\t> m       Anzeigen des arithemtischen Mittelwertes\n");
  227.     printf("\t> c       Mit diesem Befehl koennen sie den Screen clearen\n");
  228.     printf("\t> sp      Anzeigen der Spannweite\n");
  229.     printf("\t> me      Anzeigen des Medians\n");
  230.     printf("\t> mo      Anzeigen des Modalwertes\n");
  231.     printf("\t> ?       Anzeigen der Hilfe\n");
  232.     printf("\t> q       Beenden des Programms\n");
  233. }
  234. /********************************************************
  235. Funktionsname: displayIntArr
  236. =======================================================
  237. Zweck: Zeigt das Array an
  238. =======================================================
  239. Variablen / Felder:
  240.                 i: Zählervariable für Schleife
  241. =======================================================
  242. Return-Wert: keinen
  243. *******************************************************
  244. */
  245. void displayIntArr(const int *f, size_t n) { //Da das Array nicht beschrieben werden soll, wird es als const behandelt
  246.     int i;    //Zählervariable
  247.     putchar('\t'); //Damit der Style, in dem ausgegeben wird, konsistent bleibt, wird ein Tab ausgegeben
  248.     for(i = 0; i < n; i++) { //Zählen bis das Array zu Ende ist
  249.         printf("%d ", f[i]); //Ausgabe der Werte
  250.     }
  251. }
  252.  
  253. /********************************************************
  254. Funktionsname: werteEinlesen
  255. =======================================================
  256. Zweck: Einlesen der Werte und speichern auf das Array
  257. =======================================================
  258. Variablen / Felder:
  259.             usereingabe[300]: Dient zum Speichern des
  260.             Strings wenn der User eine Zahl eingibt
  261.  
  262.             ok:Prüft durch die Anzahl der gespeicherten Werte
  263.             um alles glatt gelaufen ist
  264.  
  265.             userfertig: Dient zum Überprüfen ob der
  266.             User fertig ist, mit eingeben oder nicht
  267.             Durch eine Switch-Case wird der Wert gesetzt
  268.  
  269.             userdone: Speichert die Auswahl des Users,
  270.             ober weitermachen möchte oder nicht
  271. =======================================================
  272. Return-Wert: keinen
  273. *******************************************************
  274. */
  275. void werteEinlesen(int *f, int *weing) {
  276.     system("cls");  //Clearen ds Bildschirms
  277.     int i;          //Zählervariable
  278.     char usereingabe[300];  //Array für die Usereingabe
  279.     int ok;                 //Prüft ob alles glattgelaufen
  280.     int wert;
  281.     int userfertig = 1;
  282.     char dummy;
  283.     if(weing == 49 ) {
  284.         fehlermeldung(1);
  285.     } else {
  286.         while(userfertig) {
  287.  
  288.             printf("\n\tWert eingeben > ");
  289.             ok = sscanf(gets(usereingabe), "%d%c", &f[*weing], &dummy);
  290.             if(ok == 2) {
  291.                 fehlermeldung(2);
  292.                 userfertig = 1;
  293.                 i++;
  294.             } else {
  295.                 (*weing)++;
  296.                 userfertig = 0;
  297.             }
  298.  
  299.  
  300.         }
  301.     }
  302. }
  303. /********************************************************
  304. Funktionsname: sortedanzeigen
  305. =======================================================
  306. Zweck: Anzeigen des sortierten Feldes
  307. =======================================================
  308. Variablen / Felder:
  309.             fcopy[gross]:
  310.             Array, welches eine Kopie vom Original ist
  311. =======================================================
  312. Return-Wert: keinen
  313. *******************************************************
  314. */
  315. void sortedanzeigen(const int *f, size_t n) {
  316.     int fcopy[gross];
  317.     copyfeld(f, fcopy, n);
  318.     sortfeld(fcopy, n);
  319.     displayIntArr(fcopy, n);
  320. }
  321.  
  322. /********************************************************
  323. Funktionsname: copyfeld
  324. =======================================================
  325. Zweck: Kopieren des Feldes, da ursprüngliches unangetastet
  326. sein soll
  327. =======================================================
  328. Variablen / Felder:
  329.             i: Zählervariable für Schleife
  330. =======================================================
  331. Return-Wert: keinen
  332. *******************************************************
  333. */
  334. void copyfeld(const int *f, int *fcopy, size_t n) {
  335.     int i;
  336.     for(i = 0; i <= n; i++) {
  337.         fcopy[i] = f[i];
  338.     }
  339. }
  340. /********************************************************
  341. Funktionsname: spberechnung
  342. =======================================================
  343. Zweck: Berechnen der Spannweite
  344. =======================================================
  345. Variablen / Felder:
  346.             i: Zählervariable für Schleife
  347.             min: Kleinster Wert, für Berechnung notwendig
  348.             max: Größter Wert, für Berechnung notwendung
  349. =======================================================
  350. Return-Wert: max - min -> Größe der Spannweite
  351. *******************************************************
  352. */
  353. int spberechnung(const int *f, size_t n) {
  354.     int i;
  355.     int min, max = f[0]; //Setzen der Werte auf den ersten Array wert
  356.  
  357.     for(i = 0; i < n; i++) {
  358.  
  359.         if(f[i] < min) {  //Wenn kleiner, wird neues min gesetzt
  360.             min = f[i];   //Setzen des mins auf neuen Wert
  361.         }
  362.  
  363.         if(f[i] > max) { //Wenn größer, wird neues max gesetzt
  364.             max = f[i];  //Setzen des max auf neuen Wert
  365.         }
  366.  
  367.     }
  368.     return max-min; //Zurückgeben der Spannweite
  369. }
  370. /********************************************************
  371. Funktionsname: calcarithm
  372. =======================================================
  373. Zweck: Berechnen des arithemtischen Mittels
  374. =======================================================
  375. Variablen / Felder:
  376.             summe = die Summe aller addierten Werte
  377.             i: Zählervariable
  378. =======================================================
  379. Return-Wert: summe / n -> Die Summe durch n Werte =
  380.              Arithemthisches Mittel
  381. *******************************************************
  382. */
  383. double calcarithm(int *f, size_t n) {
  384.     int summe = 0;
  385.     int i;
  386.  
  387.     for(i = 0; i < n + 1; i++) {
  388.         summe+=f[i];
  389.     }
  390.     return summe / n;
  391. }
  392. /********************************************************
  393. Funktionsname: median
  394. =======================================================
  395. Zweck: Berechnen des Medians
  396. =======================================================
  397. Variablen / Felder:
  398.             fcopy[gross]: Kopie von Original-Array
  399.  
  400.             summe: Falls die Anzahl der Werte gerade ist,
  401.             wird hier die Summe gespeichert
  402.  
  403.             median: Wert des Medians
  404.  
  405. =======================================================
  406. Return-Wert: median -> Wert des Medians
  407. *******************************************************
  408. */
  409. double median(const int *f, size_t n) {
  410.     int fcopy[gross];
  411.     double  summe = 0;
  412.     double median = 0;
  413.  
  414.     copyfeld(f, fcopy, n);
  415.     sortfeld(fcopy, gross);
  416.  
  417.     if(n % 2 == 1) {
  418.         median = fcopy[n/2];
  419.     } else {
  420.  
  421.         summe = fcopy[n / 2] + fcopy[n/2-1];
  422.         median = summe / 2;
  423.     }
  424.     return median;
  425. }
  426.  
  427. int modalwert(const int *f, size_t n, int *modal) {
  428.     int fcopy[gross];
  429.     int counter = 0;
  430.     int countermax = 0;
  431.     int doppelt = 0;
  432.     int i, j;
  433.     copyfeld(f, fcopy, n);
  434.     sortfeld(fcopy, n);
  435.     for(i = 0; i < n; i++) {
  436.         if(fcopy[i] == fcopy[i + 1]) {
  437.             counter++;
  438.  
  439.         }
  440.         if(counter == countermax)
  441.         {
  442.             doppelt++;
  443.         }
  444.         if(counter > countermax)
  445.             {
  446.                 countermax = counter;
  447.                 *modal = fcopy[i];
  448.                 return 1;
  449.             } else {
  450.                 return 0;
  451.             }
  452.         }
  453.     }
  454.  
  455.  
  456.  
  457. void sortfeld(int *f, size_t n) {
  458.     int i, j, h;
  459.     for(i = 1; i < n; i++) {
  460.         for(j = 0; j < n - i; j++) {
  461.             if(f[j] > f[j + 1]) {
  462.                 h = f[j];
  463.                 f[j] = f[j + 1];
  464.                 f[j + 1] = h;
  465.             }
  466.         }
  467.     }
  468. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!