C-Programm



  • Anfänger_2015 schrieb:

    hallo Bruce,

    Heute zuviel Fernsehen geschaut?

    Wenn du nicht weißt was Brute Force ist, lies es nochmal bei Wikipedia nach.

    Anfänger_2015 schrieb:

    Die Möglichkeiten werden berechnet und ausgegeben. Sind aber aufgrund der Breite von den Messern nicht alle realisierbar. jetzt muss mein Programm die Möglichkeiten mit Berücksichtigung der Messerbreite bzw. schnittstelle welche Möglichkeit tatsächlich zu realisieren ist.

    Du sollst, wenn du alle möglichen Reihenfolge hast, dies auch noch mit den Messerbreiten durchrechnen.



  • verzeihe lieber Dirk,

    ich weiß nicht wie ich auf Bruce kam. tut mir leid.

    du hast recht, die Messerbreite ist im zusammenhag mit den Abständen zwischen den Schnittstellen zu berücksichtigen. Mein Problem ist, wie ich die Informationen in einem c code umsetzen soll



  • Du musst überprüfen, ob die Differenz zwischen den Schnitten genug Platz für die Säge lässt. Wenn du Sägen überspringst, muss halt entsprechen Platz sein.

    int saege[5] = {0,1,2,4,5}; Eine Möglichkeit
    int schnitte[5] = {0, 400, 700, 1000, 1300};
    int mindestbreite = 200;
    
    set fail = 0
    for(i=1;i<5;i++)
    {  if (schnitte[i]-schnitte[i-1] < (saege[i]-saege[i-1]) * mindestbreite )
       { fail = 1;
         break;
       }
    }
    

    Im übrigen brauchst du nur eine fak Funktion.



  • Achso, Hellsehen kann ich auch nicht. Die Glaskugel ist auf der Arbeit.

    Aber ich habe http://www.mikrocontroller.net/topic/363081 gefunden.



  • vielen lieben Dank!!!!!! sehr guter Hinweis...ich probiere es sofort



  • lieber dirk,
    Mein Problem ist, dass das Programm selbstständig alle möglichkeiten prüfen muss


  • Mod

    Dir ist wirklich nur schwer zu helfen, der Grund dafür bist du selber.

    Anfänger_2015 schrieb:

    lieber dirk,
    Mein Problem ist, dass das Programm selbstständig alle möglichkeiten prüfen muss

    Wieso ist das ein Problem? Du scheinst mit deinen Beitragen Fragen beantworten zu wollen, aber stiftest nur mehr Verwirrung.

    http://www.tty1.net/smart-questions_de.html

    Wenn du Schwierigkeiten mit Deutsch haben solltest, versuch es auf Englisch oder mit einer anderen Sprache, die dir besser liegt.

    Und beim nächsten Mal wähle bitte passende Threadtitel. Um C-Programme geht es in jedem Thread in diesem Forum.



  • sorry, dass ich für Verwirrung sorge und dass mein Deutsch nicht gut genug ist.

    Problem ist folgendes:

    int saege[5] = {0,1,2,4,5}; ..... mit dem Befehlt, wird nur die eine Möglichkeit geprüft.

    Meine Aufgabe ist aber, alle Möglichkeiten zu prüfen.

    Wenn ich 100 Möglichkeiten habe, ich kann sie nicht alle eingeben und prüfen lassen. Deswegen macht es mehr Sinn, wenn ich mein C-Code erweitere, dass er nicht nur die Möglichkeiten ausgibt, sondern auch prüft.


  • Mod

    Dein Problem ist also die Erzeugung der verschiedenen Möglichkeiten?

    Falls du glaubtest, dass dein Code zur Berechnung der Anzahl der Möglichkeiten irgendwie ein Teilschritt dahin war: Das ist ungefähr so sinnvoll, wie vor dem Rasenmähen die Anzahl der Grashalme zu zählen.

    Das Erzeugen aller eindeutigen, geordneten Kombinationen ist nicht ganz trivial (zumindest in C, ganz ohne Hilfsmittel). Ich versuche da mal was vorzubereiten, aber habe gerade nicht genug Zeit. Es kann sein, dass die Antwort erst Montag kommt.



  • Montag ist gut...vielen Dank 🙂



  • [code="cs"] Hallo leute, kann mir jdn bitte sagen, warum das programm nicht das macht, was er eigentlich machen muss....danke 🙂
    #include <stdio.h>
    #include <stdlib.h>

    long unsigned fak(const unsigned wert)
    {
    long unsigned n = 1;
    for (unsigned i = 1; i <= wert; ++i)
    n *= i;
    return n;
    }

    void print_array(const unsigned k, const unsigned *const combination)
    {
    static unsigned count = 0;

    printf("%5u. Moeglichkeit: ( ", ++count);
    for(unsigned i = 0; i < k - 1; i++)
    printf("%u,", combination[i]);
    printf("%u )\n", combination[k - 1]);
    }

    void Moeglichkeiten(const unsigned n, const unsigned k, unsigned *const combination, const unsigned x)
    {
    unsigned i,j;
    unsigned max;

    int schnitte[5] = {0, 400, 700, 1000, 1300};
    int mindestbreite = 200;

    for(j=1 ; j < 5 ; j++)
    {
    if(x < k && schnitte[i]-schnitte[i-1] < (combination[x]-combination[x-1]) * mindestbreite)

    {
    max = x ? combination[x - 1] : 0;

    for(i = max + 1; i <= n - k + x + 1; i++)
    {


    Moeglichkeiten(n, k, combination, x + 1);

    }
    }
    else
    print_array(k, combination);
    }
    }

    int main (int argc, char *argv[])
    {
    unsigned Moeglichkeit = 0,
    n = 5,
    m = 4,
    *combination = NULL;

    if (!(combination = (unsigned*)malloc(m * sizeof(unsigned))))
    return 1;

    Moeglichkeit = fak(n) / fak(m) / fak(n - m);

    printf("Fakultaet der Gesamtanzahl %3u! = %10lu\n", n, fak(n));
    printf("Fakultaet der Benutzten Anzahl %3u! = %10lu\n", m, fak(m));
    printf("Anzahl der Moeglichkeiten = %10u\n\n", Moeglichkeit);
    printf("alle %u vorhandenen Moeglichkeiten\n", Moeglichkeit);
    Moeglichkeiten(n, m, combination, 0);

    free(combination);

    printf("\nEnter zum beenden . . . ");
    while (getchar() != '\n');
    return 0;
    }



  • Anfänger_2015 schrieb:

    Hallo leute, kann mir jdn bitte sagen, warum das programm nicht das macht, was er eigentlich machen muss....danke

    Deppenfrage, die nichts fragt. Die Antwort wird entsprechend sein, also nichts.

    - gewöhne dir an, vernünftig einzurücken
    - gewöhne dir an, C Codetags zu benutzen
    - gewöhne dir eine vernünftige Namenskonvention an (für Variablen+Funktionen)
    - benutze keine Deppen-malloc-Cast
    - const für Basistypen bei Funktionsparametern sind Nonsens


  • Mod

    Hat, wie vorhergesehen, etwas gedauert, bis ich dazu gekommen bin. Im Prinzip ist es eine C-Implementierung verschiedener Algorithmen der C++-Standardbibliothek. Das ginge sicherlich auch effizienter (insbesondere bei der Rotation weiß ich, dass es effizienter ginge), aber die Beispielimplementierungen für C++-Algorithmen sind immer für ganz allgemeine forward-Iteratoren (wohingegen man hier random-access zur Verfügung hätte). Durch die Vermeidung der Optimierung auf random-access konnte ich dann einfach abschreiben, ohne viel nachzudenken. Außerdem ist es für kleine Kombinationen vermutlich sowieso mindestens gleich schnell wie irgendwas mit memmove oder binärer Suche:

    #include <stdio.h>
    
    // Nur für Testausgaben:
    void print_combination(int *first, int *last)
    {
      putchar('{');
      if (first != last)
        {
          printf("%d", *first);
          while (++first != last)
            printf(", %d", *first);
        }
      puts("}");
    }
    
    void ptr_swap(int *p1, int *p2)
    {
      int temp = *p1;
      *p1 = *p2;
      *p2 = temp;
    }
    
    void reverse(int *first, int *last)
    {
      while(first < --last)
        {
          ptr_swap(first++, last);
        }
    }
    
    void rotate(int *first, int *middle, int *last)
    {
      reverse(first, middle);
      reverse(middle, last);
      reverse(first, last);
    }
    
    int next_combination(int *first, int *middle, int *last)
    {
      if ((first == last) || (first == middle) || (last == middle) || (last == first + 1))
        return 0;
       int  *i1 = middle;
       int  *i2 = last - 1;
       while (first != i1)
         {
           if (*--i1 < *i2)
             {
               int *j = middle;
               while (!(*i1 < *j)) ++j;
               ptr_swap(i1, j);
               ++i1;
               ++j;
               i2 = middle;
               rotate(i1, j, last);
               while (last != j)
                 {
                   ++j;
                   ++i2;
                 }
               rotate(middle, i2, last);
               return 1;
             }
         }
       rotate(first, middle, last);
       return 0;
    }
    
    int main()
    {
      int combo[] = {1, 2, 3, 4, 5};
      const int alphabet_length = sizeof(combo)/ sizeof(*combo);
      int i;
    
      for (i = 0; i <= alphabet_length; ++i)
        {  
          printf("Alle Kombinationen der Länge %d:\n", i);
          do
            {
              print_combination(combo, combo + i); // Hier stattdessen dein Code, der irgendwas mit der Kombination macht
            }
          while (next_combination(combo, combo + i, combo + alphabet_length));
        }
      return 0;
    }
    

Anmelden zum Antworten