daily pastebin goal
29%
SHARE
TWEET

Untitled

a guest Mar 13th, 2018 47 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // ConsoleApplication5.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung.
  2. //
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <malloc.h>
  7. #include <string.h>
  8.  
  9. typedef struct baustein
  10. {
  11.     int hoehe;
  12.     int breite;
  13.     int length;
  14.     int rot;
  15.     int gruen;
  16.     int blau;
  17. } BAUSTEIN;
  18.  
  19. void eingabeBS(BAUSTEIN *bs);
  20. void ausgabeBS(BAUSTEIN bs);
  21. int compareBS(BAUSTEIN bs1, BAUSTEIN bs2);
  22. void rem(BAUSTEIN *bs, int stelle, int length);
  23. int auswahl();
  24. int getVolume(BAUSTEIN bs);
  25. void compare(int length, BAUSTEIN *lego);
  26. void quicksort(int links, int rechts, BAUSTEIN feld[]);
  27. void speichern(int length, BAUSTEIN *lego);
  28. int read(BAUSTEIN *lego, int length);
  29.  
  30. int main()
  31. {
  32.     BAUSTEIN *legobausteine;
  33.     legobausteine = (BAUSTEIN*)malloc(1 * sizeof(BAUSTEIN));
  34.     int length = 0;
  35.     int command = 1;
  36.     int chosen;
  37.     while (1)
  38.     {
  39.         system("cls");
  40.         command = auswahl();
  41.         switch (command)
  42.         {
  43.         case 0:
  44.             length++;
  45.             legobausteine = (BAUSTEIN *)realloc(legobausteine, sizeof(BAUSTEIN) * length);
  46.             eingabeBS(&legobausteine[length - 1]);
  47.             break;
  48.         case 1:
  49.             printf("Welches der Elemente von [0; %d[ soll ausgegeben werden: ", length);
  50.             scanf("%d", &chosen);
  51.             if (chosen < 0 || chosen > length - 1)
  52.             {
  53.                 printf("Dies ist keine gueltige Eingabe!\n");
  54.                 system("pause");
  55.                 break;
  56.             }
  57.             ausgabeBS(legobausteine[chosen]);
  58.             break;
  59.         case 2:
  60.             printf("Welches der Elemente von [0; %d[ soll entfernt werden: ", length);
  61.             scanf("%d", &chosen);
  62.             if (chosen < 0 || chosen > length - 1)
  63.             {
  64.                 printf("Dies ist keine gueltige Eingabe!\n");
  65.                 system("pause");
  66.                 break;
  67.             }
  68.             rem(legobausteine, chosen, length);
  69.             length--;
  70.             break;
  71.         case 3:
  72.             compare(length, legobausteine);
  73.             break;
  74.         case 4:
  75.             if (length != 0)
  76.             {
  77.                 quicksort(0, length - 1, legobausteine);
  78.             }
  79.             else
  80.             {
  81.                 printf("\nEs sind keine Inhalte vorhanden!\n");
  82.                 system("pause");
  83.             }
  84.             break;
  85.         case 5:
  86.             speichern(length, legobausteine);
  87.             break;
  88.         case 6:
  89.             length = read(legobausteine, length);
  90.             printf("FINAL: %d", legobausteine[length-1].length);
  91.             system("pause");
  92.             break;
  93.         case 7:
  94.             return 0;
  95.         default:
  96.             printf("Das ist kein gueltiger Befehl!\n");
  97.             system("pause");
  98.             break;
  99.         }
  100.     }
  101.     return 0;
  102. }
  103.  
  104. void speichern(int length, BAUSTEIN *lego)
  105. {
  106.     FILE *f = fopen("data.txt", "w");
  107.  
  108.     for (int i = 0; i < length; i++)
  109.     {
  110.         fprintf(f, "%d;%d;%d;%d;%d;%d;", lego[i].hoehe, lego[i].breite, lego[i].length, lego[i].rot, lego[i].gruen, lego[i].blau);
  111.     }
  112.     fprintf(f, "\n");
  113.     fclose(f);
  114. }
  115.  
  116. int read(BAUSTEIN *lego, int length)
  117. {
  118.     FILE *f;
  119.     f = fopen("data.txt", "r");
  120.     if (f)
  121.     {
  122.         int c;
  123.         char buff[300];
  124.         int counter = 0;
  125.         while ((c = getc(f)) != EOF)
  126.         {
  127.             buff[counter] = c;
  128.             counter++;
  129.         }
  130.         fclose(f);
  131.  
  132.         char *data;
  133.         data = strtok(buff, "\n");
  134.         printf("Daten: %s", &data[0]);
  135.         int wert = 0;
  136.         char *temp;
  137.  
  138.         temp = strtok(data, ";");
  139.  
  140.         while(temp != NULL){
  141.             if(wert % 6 == 0){
  142.                 printf("\nReallokiert!\n");
  143.                 length++;
  144.                 lego = (BAUSTEIN *)realloc(lego, sizeof(BAUSTEIN) * length);
  145.             }
  146.             printf("\n%d", atoi(temp));
  147.             switch(wert % 6){
  148.                 case 0:
  149.                     lego[length - 1].hoehe = atoi(temp);
  150.                     printf("Wert hier: %d\n",lego[length-1]);
  151.                 case 1:
  152.                     lego[length - 1].breite = atoi(temp);
  153.                 case 2:
  154.                     lego[length - 1].length = atoi(temp);
  155.                 case 3:
  156.                     lego[length - 1].rot = atoi(temp);
  157.                 case 4:
  158.                     lego[length - 1].gruen = atoi(temp);
  159.                 case 5:
  160.                     lego[length - 1].blau = atoi(temp);
  161.                 }
  162.             temp = strtok(NULL, ";");
  163.             wert++;
  164.         }
  165.     }
  166.     else
  167.     {
  168.         printf("Es sind noch keine Daten vorhanden!");
  169.     }
  170.     return length;
  171. }
  172.  
  173. void compare(int length, BAUSTEIN *lego)
  174. {
  175.     int eing1, eing2;
  176.     printf("Welche Bausteine sollen miteinander verglichen werden? Waehle 2 Bausteine im Intervall [0; %d[!\n", length);
  177.     printf("Baustein 1: ");
  178.     scanf("%d", &eing1);
  179.     printf("\nBaustein 2: ");
  180.     scanf("%d", &eing2);
  181.     printf("\n");
  182.     if (eing1 < 0 || eing1 >= length || eing2 < 0 || eing2 >= length)
  183.     {
  184.         printf("Mindestens 1 der Bausteine existiert nicht! Bitte taetige eine andere Eingabe!\n");
  185.         system("pause");
  186.         return;
  187.     }
  188.     int vol1, vol2;
  189.     vol1 = getVolume(lego[eing1]);
  190.     vol2 = getVolume(lego[eing2]);
  191.     if (vol1 == vol2)
  192.     {
  193.         printf("Die beiden Bausteine sind gleich gross!\n");
  194.     }
  195.     else if (vol1 < vol2)
  196.     {
  197.         printf("Der 1. Legobaustein ist um %d mm^3 kleiner als der 2.\n", vol2 - vol1);
  198.     }
  199.     else
  200.     {
  201.         printf("Der 1. Legobaustein ist um %d mm^3 groesser als der 2.\n", vol1 - vol2);
  202.     }
  203.     system("pause");
  204. }
  205.  
  206. void quicksort(int links, int rechts, BAUSTEIN feld[])
  207. {
  208.     int pivot = rechts--;
  209.     BAUSTEIN cache;
  210.  
  211.     while (links <= rechts)
  212.     {
  213.         if (getVolume(feld[links]) > getVolume(feld[pivot]) && getVolume(feld[rechts]) < getVolume(feld[pivot]))
  214.         {
  215.             cache = feld[links];
  216.             feld[links] = feld[rechts];
  217.             feld[rechts] = cache;
  218.             links++;
  219.             rechts--;
  220.         }
  221.         if (getVolume(feld[links]) <= getVolume(feld[pivot]))
  222.         {
  223.             links++;
  224.         }
  225.         if (getVolume(feld[rechts]) >= getVolume(feld[pivot]))
  226.         {
  227.             rechts--;
  228.         }
  229.     }
  230.     cache = feld[links];
  231.     feld[links] = feld[pivot];
  232.     feld[pivot] = cache;
  233.  
  234.     if (rechts >= 1)
  235.     {
  236.         quicksort(0, rechts, feld);
  237.     }
  238.     if (pivot - links > 1)
  239.     {
  240.         quicksort(links + 1, pivot, feld);
  241.     }
  242. }
  243.  
  244. int getVolume(BAUSTEIN bs)
  245. {
  246.     return bs.breite * bs.hoehe * bs.length;
  247. }
  248.  
  249. int auswahl()
  250. {
  251.     int command = 0;
  252.     char input = 10;
  253.     while (input != 13)
  254.     {
  255.         system("cls");
  256.         printf("Waehle eine Methode aus: (s und w zum navigieren nutzen!)\n");
  257.         if (command == 0)
  258.         {
  259.             printf("\033[32m[0] - Baustein hinzufuegen\n\033[0m");
  260.         }
  261.         else
  262.         {
  263.             printf("[0] - Baustein hinzufuegen\n");
  264.         }
  265.         if (command == 1)
  266.         {
  267.             printf("\033[32m[1] - Baustein anzeigen\n\033[0m");
  268.         }
  269.         else
  270.         {
  271.             printf("[1] - Baustein anzeigen\n");
  272.         }
  273.         if (command == 2)
  274.         {
  275.             printf("\033[32m[2] - Baustein entfernen\n\033[0m");
  276.         }
  277.         else
  278.         {
  279.             printf("[2] - Baustein entfernen\n");
  280.         }
  281.         if (command == 3)
  282.         {
  283.             printf("\033[32m[3] - Baustein vergleichen\n\033[0m");
  284.         }
  285.         else
  286.         {
  287.             printf("[3] - Baustein vergleichen\n");
  288.         }
  289.         if (command == 4)
  290.         {
  291.             printf("\033[32m[4] - Bausteine sortieren\n\033[0m");
  292.         }
  293.         else
  294.         {
  295.             printf("[4] - Bausteine sortieren\n");
  296.         }
  297.         if (command == 5)
  298.         {
  299.             printf("\033[32m[5] - Daten speichern\n\033[0m");
  300.         }
  301.         else
  302.         {
  303.             printf("[5] - Daten speichern\n");
  304.         }
  305.         if (command == 6)
  306.         {
  307.             printf("\033[32m[6] - Daten einlesen\n\033[0m");
  308.         }
  309.         else
  310.         {
  311.             printf("[6] - Daten einlesen\n");
  312.         }
  313.         if (command == 7)
  314.         {
  315.             printf("\033[32m[7] - Programm beenden\n\033[0m");
  316.         }
  317.         else
  318.         {
  319.             printf("[7] - Programm beenden\n");
  320.         }
  321.         input = getch();
  322.         if (input == 'W' || input == 'w')
  323.         {
  324.             if (command > 0)
  325.             {
  326.                 command--;
  327.             }
  328.         }
  329.         else if (input == 'S' || input == 's')
  330.         {
  331.             if (command < 7)
  332.             {
  333.                 command++;
  334.             }
  335.         }
  336.     }
  337.     return command;
  338. }
  339.  
  340.  
  341.  
  342. void rem(BAUSTEIN *bs, int stelle, int length)
  343. {
  344.     bs[stelle] = bs[length - 1];
  345.     bs = (BAUSTEIN*)realloc(bs, (length - 1) * sizeof(BAUSTEIN));
  346. }
  347.  
  348. int compareBS(BAUSTEIN bs1, BAUSTEIN bs2)
  349. {
  350.     int vol1 = bs1.hoehe * bs1.length * bs1.breite;
  351.     int vol2 = bs2.hoehe * bs2.length * bs2.breite;
  352.  
  353.     if (vol1 > vol2)
  354.     {
  355.         return 1;
  356.     }
  357.     else if (vol1 < vol2)
  358.     {
  359.         return 2;
  360.     }
  361.     else
  362.     {
  363.         return 3;
  364.     }
  365. }
  366.  
  367. void ausgabeBS(BAUSTEIN bs)
  368. {
  369.     printf("Die Hoehe betraegt %d mm\n", bs.hoehe);
  370.     printf("Die Breite betraegt %d mm\n", bs.breite);
  371.     printf("Die length betraegt %d mm\n", bs.length);
  372.     printf("Der Rotwert betraegt %d \n", bs.rot);
  373.     printf("Der Gruenwert betraegt %d \n", bs.gruen);
  374.     printf("Der Blauwert betraegt %d \n", bs.blau);
  375.     system("pause");
  376. }
  377. void eingabeBS(BAUSTEIN *bs)
  378. {
  379.     printf("Gib die Hoehe ein: ");
  380.     scanf("%d", &bs->hoehe);
  381.     printf("Gib die Breite ein: ");
  382.     scanf("%d", &bs->breite);
  383.     printf("Gib die length ein: ");
  384.     scanf("%d", &bs->length);
  385.     printf("Gib den Wert fuer rot ein: ");
  386.     scanf("%d", &bs->rot);
  387.     printf("Gib den Wert fuer gruen ein: ");
  388.     scanf("%d", &bs->gruen);
  389.     printf("Gib den Wert fuer blau ein: ");
  390.     scanf("%d", &bs->blau);
  391. }
RAW Paste Data
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
 
Top