Add files via upload

Author: ethan42

samples/code/README.md

@@ -1,12 +1,31 @@
-# Πρόγραμμα Περιστροφής Εικόνας
-
-Το πρόγραμμα δέχεται το ωμό περιεχόμενο μιας bitmap εικόνας και στέλνει στο standard output μια εκδοχή της που έχει περιστραφεί δεξιόστροφα, κατά 90 μοίρες.
-Αρχικά διαβάζω την τιμή `pixel_array_offset` για να αποθηκεύσω το πλήθος των bytes που απαιτούνται για την αποθήκευση του header και του other data.
-Αμέσως μετά δημιουργώ ένα αντίγραφο των δεδομένων, διαβάζω τις χρήσιμες πληροφορίες χρησιμοποιώντας casting σε uint32_t pointer, και κάνω malloc μια δισδιάστατη λίστα για
-να αποθηκεύσω και να τροποποιήσω τα περιεχόμενα των pixels. Υπολογίζω το νέο padding έτσι ώστε κάθε στήλη να έχει μέγεθος πολλαπλάσιο του τέσσερα και στέλνω τις αλλαγές μου στο standard output.
-
-Για να καταλάβω πως θα υλοποιήσω το transformation, περιέγραψα σε χαρτί την διαδικασία περιστροφής μιας οποιοασδήποτε εικόνας και μετέφερα το σκεπτικό στο πρόγραμμα δίνοντας ιδιαίτερη προσοχή στον τρόπο με τον οποίο κάνω iterate τις στήλες και τις γραμμές. Ουσιαστικά μετατρέπω κάθε στήλη σε γραμμή, αφού πρώτα αντιστρέψω την σειρά των pixels της.
-
-Αφού τελειώσω με την επεξεργασία των δεδομένων κάνω `free()` για να αποφύγω τα πιθανά μαίμωρει λειξ. Αρχικά είχα προσπαθήσει να κάνω χρήση της `fseek(stdin, padding, SEEK_SET)` για να αποφύγω την ανάγνωση των κενών, αλλά η συγκεκριμένη συνάρτηση δεν λειτουργούσε για pipes αλλά μόνο σε απλές περιπτώσεις ανακατεύθυνσης.
-
-Χρησιμοποίησα τον preprocessor (#define) για να μην περιλάβω magic numbers στο πρόγραμμά μου. Επιπλέον, αν ποτέ χρειαστεί να διορθώσω οποιοδήποτε offset αρκεί μονάχα να αλλάξω την γραμμή του declaration του, και όχι όλες τις περιπτώσεις που αυτή χρησιμοποιείται!
+# Εργασία 2 - Άσκηση 2: DNA Matching  
+
+### Σχόλιο 1 - Η πρώτη σκέψη
+Για να βρούμε τη μέγιστη κοινή αλυσίδα, πρέπει να συγκρίνουμε κάθε χαρακτήρα του dna2 με κάθε χαρακτήρα του dna1 και να βρούμε ποιος είναι ο μέγιστος αριθμός διαδοχικών βάσεων που είναι ίδιες και στα δύο dna.
+Θα βοηθούσε να κάναμε τη σύγκριση αυτή με ένα δισδιάστο πίνακα dnas[dna1_length][dna2_length], του οποίου η εγγραφή dnas[i][j] θα ήταν ίση με 1 μόνο αν dna1[i] == dna2[j], αλλιώς 0. Μετά, θα ήταν εύκολο να βρούμε τη μέγιστη κοινή αλυσίδα, αφού αυτή θα αντιστοίχουσε στη μακρύτερη διαγώνιο από άσσους.<br>
+Π.χ.   A C T G C G G<br>
+    A  1 0 0 0 0 0 0 <br>
+    G  0 0 0 1 0 1 1<br>
+    T  0 0 <strong>1</strong> 0 0 0 0 <br>
+    G  0 0 0 <strong>1</strong> 0 1 1 <br>
+    C  0 1 0 0 <strong>1</strong> 0 0 <br>
+    A  1 0 0 0 0 0 0 <br>
+Ωστόσο, για μεγάλες αλυσίδες, αυτή η τεχνική οδηγεί σε άσκοπη σπατάλη μνήμης, η δέσμευση της οποίας ακόμη και στο σωρό υπάρχει πιθανότητα να αποτύχει .<br>
+
+### Σχόλιο 2 - Προσπάθεια εξοικονόμησης μνήμης - η συνάρτηση find_longest_common_sequence
+Παρατήρωντας τον παραπάνω πίνακα από κάτω προς τα πάνω, φαίνεται ότι ίσως να μπορούσαμε να ξεφορτωθούμε περιττές γραμμές, αν σε κάθε επόμενη αθροίζαμε τα μέγιστα μήκη κοινών ακολουθιών που είχαμε εντοπίσει ως την προηγούμενη.
+Έτσι, δημιουργούμε έναν πίνακα common_suffixes με μέγεθος dna1_length, τον οποίο ανανεώνουμε dna2_length φορές, προσθέτωντας κάθε φορά τις νέες κοινές βάσεις (που αλλάζουν τα μήκη των μέγιστων κοινών καταλήξεων) και ανανεώνοντας σε κάθε αλλαγή τις global μεταβλητές max_length και starting_index. <br>
+Κατά την εκτέλεση του προγράμματος για το παραπάνω παράδειγμα, ο πίνακας θα είχε αυτή την εξέλιξη:
+ <br><br>
+1 0 0 0 0 0 0       <br>
+0 1 0 0 1 0 0       <br>
+0 0 0 2 0 1 1       
+0 0 3 0 0 0 0     <br>
+0 0 0 1 0 1 1       <br>
+1 0 0 0 0 0 0       <br>
+
+Ιδιαίτερη σημασία έχει το γεγονός ότι η ανανέωση του common_suffixes πραγματοποιείται κατά μήκος διαγωνίων και όχι καθέτως, αφού αν dna1[i] == dna2[j] δεν θέλουμε dna1[i] = dna2[j+1], αλλά dna1[i+1] = dna2[j+1], ώστε οι κοινές βάσεις να είναι διαδοχικές και στα δύο dna.<br>
+Αν κάποιο ζεύγος βάσεων δεν είναι κοινό, τότε διακόπτεται και η κοινή αλυσίδα βάσεων (η διάγωνιος) που οδηγούσε σε αυτό και η τιμή του αντίστοιχου στοιχείου στον πίνακα common_suffixes γίνεται 0. Ωστόσο, αν το μήκος της ακολουθίας που είχε δημιουργηθεί μέχρι εκείνη τη στιγμή ήταν μέγιστο, αυτό έχει αποθηκευτεί.<br> 
+
+Μετά τον τερματισμό της συνάρτησης (όταν δεν υπάρχουν πια άλλες βάσεις στο dna2 για να συγκριθούν), γνωρίζουμε και το μέγιστο μήκος και το σημείο του dna1 όπου αρχίζει η μέγιστη κοινή ακολουθία, άρα μπορούμε να την προσδιόρισουμε και να την τυπώσουμε.<br>
+Με αυτόν τον τρόπο, κατάφεραμε από Ο(n * m) μνήμη να χρησιμοποιούμε μόνο Ο(n), όπου n = dna1_length και m = dna2_length.

samples/code/dna.c

@@ -0,0 +1,116 @@
+/*
+Φοιτήτρια: Ματίνα Ναδάλη
+Καθηγητής: Αυγερινός Αθανάσιος
+Μάθημα: Εισαγωγή στον προγραμματισμό
+Πρόγραμμα dna.c : Εκτυπώνει την μέγιστη κοινή αλυσίδα DNA ανάμεσα σε δύο
+δείγματα
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+int dna1_length, dna2_length;
+int max_length = 0;
+int starting_index = 0;  //η θέση του πρώτου στοιχείου της μέγιστης κοινής ακολουθίας στο dna1
+
+//ελέγχει αν ο χαρακτήρας είναι κάποια έγκυρη βάση
+int is_base(char character) {
+  return character == 'A' || 
+         character == 'C' || 
+         character == 'G' ||
+         character == 'T';
+}
+
+//θέτει τη global μεταβλητή starting_index στο index του χαρακτήρα του dna1, από
+//τον οποίο αρχίζει η μέγιστη κοινή ακολουθία σχόλιο 2 στο README.md
+void find_longest_common_sequence(int *common_suffixes, int dna2_index,char *dna1, char *dna2) {
+  //συνθήκη τερματισμού - δεν υπάρχουν άλλες βάσεις στο dna2 για να συγκριθούν
+  if (dna2_index < 0) {
+    free(common_suffixes);
+    return;
+  }
+  //δεσμεύει μνήμη για τα νέα μήκη των μέγιστων κοινών καταλήξεων - όλες οι
+  //τιμές αρχικοποιούνται στο 0
+  int *new_common_suffixes = calloc(dna1_length, sizeof(int));
+  for (int i = 0; i < dna1_length; i++) {
+    if (dna1[i] == dna2[dna2_index]) {
+      //βρέθηκε νέος κοινός χαρακτήρας - η κοινή ακολουθία συνεχίζεται και το
+      //μήκος της αυξάνεται κατά 1
+      new_common_suffixes[i] = 1;
+      if (i < dna1_length - 1) {
+        new_common_suffixes[i] += common_suffixes[i + 1];
+      }
+      //ανανεώνει το μέγιστο μήκος της κοινής ακολουθίας και το starting_index
+      if (new_common_suffixes[i] > max_length) {
+        max_length = new_common_suffixes[i];
+        starting_index = i;
+      }
+    }
+  }
+  //ελευθέρωνει τη μνήμη για τα προηγούμενα μήκη των κοινών καταλήξεων
+  free(common_suffixes);
+  //ξανακαλεί τη συνάρτηση για τον προηγούμενο χαρακτήρα του dna2
+  find_longest_common_sequence(new_common_suffixes, dna2_index - 1, dna1, dna2);
+}
+
+int main(int argc, char **argv) {
+  //ελέγχει τον αριθμό των ορισμάτων
+  if (argc != 3) {
+    perror("Error: arguments missing. Usage: ./dna dnafile1 dnafile2");
+    exit(1);
+  }
+  FILE *dna1_in = fopen(argv[1], "r");
+  FILE *dna2_in = fopen(argv[2], "r");
+  if (!dna1_in || !dna2_in) {
+    perror("Error: Could not open files");
+    exit(1);
+  }
+  //δεσμεύει μνήμη στο σωρό για την αποθήκευση των ακολουθιών DNA - χρησιμοποιεί
+  //το μέγιστο δυνατό μήκος
+  char *dna1 = malloc(100000 * sizeof(char));
+  char *dna2 = malloc(100000 * sizeof(char));
+  if (!dna1 || !dna2) {
+    perror("Memory allocation failed");
+    exit(1);
+  }
+  char new_character;
+
+  //διαβάζει τους χαρακτήρες από τα αρχεία και τα καταχωρεί στους αντίστοιχους
+  //πίνακες μόνο αν αντιστοιχούν σε έγκυρη βάση
+  while (fscanf(dna1_in, "%c", &new_character) != EOF) {
+    if (is_base(new_character)) {
+      dna1[dna1_length] = new_character;
+      dna1_length++;
+    }
+  }
+  while (fscanf(dna2_in, "%c", &new_character) != EOF) {
+    if (is_base(new_character)) {
+      dna2[dna2_length] = new_character;
+      dna2_length++;
+    }
+  }
+
+  //δεσμεύει μνήμη για να αποθηκεύσει τα μήκη των μέγιστων ακολουθιών που
+  //περιέχουν κάθε χαρακτήρα του dna1 η δέσμευση γίνεται με την calloc ώστε οι
+  //τιμές να αρχικοποιηθούν στο 0
+  int *common_suffixes = calloc(dna1_length, sizeof(int));
+
+  for (int i = 0; i < dna1_length; i++) {
+    if (dna1[i] == dna2[dna2_length - 1]) {
+      common_suffixes[i] = 1;
+    }
+  }
+  find_longest_common_sequence(common_suffixes, dna2_length - 2, dna1, dna2);
+
+  //εκτυπώνει τη μέγιστη κοινή ακολουθία
+  for (int i = starting_index; i < starting_index + max_length; i++) {
+    printf("%c", dna1[i]);
+  }
+  printf("\n");
+  //απελευθερώνει τη δεσμευμένη μνήμη
+  free(dna1);
+  free(dna2);
+
+  fclose(dna1_in);
+  fclose(dna2_in);
+  return 0;
+}