C-Programm



  • Hallo zusammen,

    ich hoffe hier hilfreiche Antworten zu bekommen, wofür ich mich im
    Vorfeld herzlich bedanke!

    Es geht um u.g. c-code: er muss mir alle Kombination ausgeben von m von
    n zahlen " vorab 4 von 5 ", was bereits realisiert. jetzt muss ich die
    ausgegeben Möglichkeiten anhand weitere Vorgabe auf Plausibilität.

    Es werden wie bereits erwähnt alle Möglichkeiten ausgegeben: 1.2.3.4 &
    1.2.3.5 & 1.2.4.5 $ 1.3.4.5 % 2.3.4.5.

    Die Zahlen 1 bis 5 müssen Schneidmesser darstellen, die eine Breite x
    haben und alle hintereinander auf einer Schiene positioniert.

    jetzt muss ich eine 1800 mm lange Rolle an vier Stellen schneiden: 400,
    700, 1000, und 1300.

    Der Breite nach von den Messer wären nur 1.2.3.4 & 2.3.4.5 physikalisch
    realisierbar.

    Hat jdn vielleicht eine Idee wie ich vorgehen soll.

    #include < stdio.h >
    #include < stdlib.h >
    #include < string.h >
    //#include "_generate.h"

    int fak1 ( int wert1 )
    {
    if ( wert1 ==1) return 1;
    else return ( wert1 * fak1 ( wert1 -1));
    }

    int fak2 ( int wert2 )
    {
    if ( wert2 ==1) return 1;
    else return ( wert2 * fak2 ( wert2 -1));
    }

    void print_array( int k, int array[])
    {
    static int count = 0;
    int i;

    printf( "%d. Moeglichkeit: (", ++count);
    for( i = 0; i < k-1; i++)
    printf( "%d,", array[i]);
    printf( "%d ) \n", array[k-1]);

    }
    void Moeglichkeiten(int n, int k, int array[], int x)
    {
    int i;
    int max;

    if( x < k)
    {
    max = x ? array[x-1] : 0;

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


    Moeglichkeiten( n, k, array, x+1);
    }
    }
    else
    print_array( k, array);

    }

    int main (int argc, char *argv[])
    {
    int Moeglichkeit;

    int n = 5;
    printf("Fakultaet der Gesamtanzahl % d ! = % d \n " , n , fak1 ( n
    ));

    int m =4;
    printf("Fakultaet der Benutzten Anzahl % d ! = % d \n " , m , fak2 (
    m ));

    Moeglichkeit= fak1(n)/(fak2(m)*(fak1(n)-fak2(m)));

    printf(" Anzahl der Moeglichkeit= %d \n\n ", Moeglichkeit);

    int array[4];

    printf( "alle 5 vorhandenen Moeglichkeiten \n");
    Moeglichkeiten( 5, 4, array, 0);

    //Machine_FSM();

    }

    system("PAUSE");
    return 0;
    }



  • Brute Force.

    Rechne alle Möglichkeiten aus und streiche die, die nicht sinnvoll sind.



  • hallo Bruce, danke für die Antwort.

    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.



  • 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;
    }
    

Log in to reply