Daten mergen



  • Hallo
    Ich habe drei Dateien die ungefähr so ausschauen:

    Datei 1:

    10,10,10
    12,8,15
    

    Datei 2:

    10,10,10
    13,8,16
    20,0,0
    

    Datei 3:

    13,8,16
    20,0,0
    14,1,1
    9,9,9
    

    Nun ist es so das jede Zeile ein Portfolio ist. Ich muss nun die drei Datein mergen d.h. ich muss die Portfolios die nicht domoniert werden bzw. indifferent sind in eine Datei schreiben. In diesem Fall wär die Lösung

    Lösung:

    10,10,10
    13,8,16
    20,0,0
    14,1,1
    

    Das sind die Lösüngen die nicht dominiert werden bzw. indifferent sind

    9,9,9 wird von 10,10,10 dominiert weil es überall 1 mehr ist. 9,10,10 würde auch von 10,10,10 dominiert werden weil der erste 10 höher ist als der 9 der an nummer eins steht.
    Indifferent wäre zum Besipiel
    10,8,10 und 9,10,6

    Kann mir da jemand helfen wie ich schauen kann welche die anderen dominieren bzw das Lösungsfile kriege



  • kann mir vielleicht jemand sagen wie ich die einzelnen [Daten vergleichen kann.
    Also wie ich zum Beispiel
    die 10,10,10 aus datei 1 nehmen kann und mit allen Zeilen aus Datei 2 und 3 vergleichen kann.



  • hier meine lösung des problems.

    ich habe mich für den einfachen weg entschieden. alle dateien werden zuerst in ein array eingelesen. anschließend werden die nicht dominierten zeilen in die ausgabedatei geschrieben.

    #include <stdio.h>
    #include <stdlib.h>
    
    #define ENTRIES_PER_LINE	3
    
    int    *data      = NULL; /* array in das alle daten eingelesen werden */
                              /* wird bei bedarf alloziert*/
    size_t  data_num  = 0,    /* anzahl der zeilen, die bereits im array stehen */
    		data_size = 0;    /* maximale zahl der zeilen, die ins array passen */
    
    void
    assert_data_size (size_t size_to_assert)
    /* stelle sicher, daß das data-array mindestens */
    /* size_to_assert daten-zeilen faßt */
    {
      if(data_size<size_to_assert)
      {
        data_size=size_to_assert+100;
    
        if(data)
          data=(int*)realloc(data,data_size*ENTRIES_PER_LINE*sizeof(int));
        else
          data=(int*)malloc(data_size*ENTRIES_PER_LINE*sizeof(int));
      }
    }
    
    int
    data_lines_equal (size_t a, size_t b)
    /* gibt !=0 zurück, wenn die daten-zeilen im array data mit den indizes */
    /* a und b elementweise gleich sind. wird benutzt um doppelte zeilen */
    /* zu eliminieren */
    {
      size_t i;
    
      a*=ENTRIES_PER_LINE;
      b*=ENTRIES_PER_LINE;
    
      for(i=0; i<ENTRIES_PER_LINE; i++)
        if(data[a+i]!=data[b+i])
          return 0;
    
      return 1;
    }
    
    void
    read_data_line (FILE *fp)
    {
      size_t i,idx;
    
      assert_data_size(data_num+1);
    
      idx=data_num*ENTRIES_PER_LINE;
    
      for(i=0; i<ENTRIES_PER_LINE-1; i++)
      {
        fscanf(fp,"%d,",&data[idx+i]);
        if(feof(fp)) return;
      }
    
      fscanf(fp,"%d^[\n]",&data[idx+ENTRIES_PER_LINE-1]);
    
      /* dgelesene datenzeile nicht eintragen, wenn sie bereits vorhanden ist */
      for(i=0; i<data_num; i++)
        if(data_lines_equal(data_num,i))
          return;
    
      data_num++;
    }
    
    void
    read_data_file (char *fname)
    {
      FILE *fp;
    
      fp=fopen(fname,"r"); if(!fp) { perror(fname); exit(EXIT_FAILURE); }
    
      while(!feof(fp))
      {
        read_data_line(fp);
        if(ferror(fp)) { perror(fname); exit(EXIT_FAILURE); }
      }
    
      fclose(fp);
    }
    
    void
    write_data_line (FILE *fp, size_t idx)
    {
      size_t i;
    
      idx=idx*ENTRIES_PER_LINE;
    
      for(i=0; i<ENTRIES_PER_LINE-1; i++)
        fprintf(fp,"%d,",data[idx+i]);
    
      fprintf(fp,"%d\n",data[idx+ENTRIES_PER_LINE-1]);
    }
    
    int
    dominates (size_t a, size_t b)
    /* gibt !=0 zurück, wenn die datenzeile mit index a */
    /* die datenzeile mit index b dominiert */
    {
      size_t i;
      int    a_dominates_b=0;
    
      a*=ENTRIES_PER_LINE;
      b*=ENTRIES_PER_LINE;
    
      for(i=0; i<ENTRIES_PER_LINE; i++)
        if(data[a+i]<data[b+i])
          return 0;
        else if(data[a+i]>data[b+i])
          a_dominates_b=1;
    
      return a_dominates_b;
    }
    
    int
    is_dominated (size_t a)
    /* gibt !=0 zurück, wenn die datenzeile mit dem index a */
    /* von irgendeiner anderen datenzeile im data-array dominiert wird */
    {
      size_t i;
    
      for(i=0; i<data_num; i++)
        if(dominates(i,a))
          return 1;
    
      return 0;
    }
    
    void
    write_dominators (char *fname)
    {
      FILE   *fp;
      size_t  i,j;
    
      fp=fopen(fname,"w"); if(!fp) { perror(fname); exit(EXIT_FAILURE); }
    
      for(i=0; i<data_num; i++)
        if(!is_dominated(i))
          write_data_line(fp,i);
    
      fclose(fp);
    }
    
    int
    main (int argc, char *argv[])
    {
      read_data_file("C:\\datei 1.txt");
      read_data_file("C:\\datei 2.txt");
      read_data_file("C:\\datei 3.txt");
    
      write_dominators("C:\\dominatoren.txt");
    
      return EXIT_SUCCESS;
    }
    

    hab noch ein paar kommentare hinzugefügt 😉


Log in to reply