Δευτέρα, 4 Ιανουαρίου 2016

Ο πίνακας κατακερματισμού 2.0 στα ελληνικά!

Το πρόγραμμα από εδώ το μετέτρεψα με ελληνικές εντολές (η Μ2000 έχει δυο σετ εντολών), αλλά άφησα τις μεταβλητές και τις λεζάντες στα ελληνικά
Δείτε ότι τα αντικείμενα διατηρούν επίσης τα ονόματα των συναρτήσεων και των τμημάτων στα αγγλικά. Θα μπορούσαμε να χρησιμοποιήσουμε διπλά ονόματα, χωρίς διπλούς πλήρεις ορισμούς:

Ομάδα Α {
      Συνάρτηση {
            \\ Μια φορά ο κώδικας
            Διάβασε Α, Β
            Βάλε Α*Β
      }
      Συνάρτηση L {
            Κάλεσε .LΛ() ' καλούμε τη συνάρτηση ως τμήμα
            =Αριθμός
      }
      Συνάρτηση Λ {
            Κάλεσε .LΛ()
            =Αριθμός
      }
      Τμήμα ΑΛΦΑ {
            .ALFA
      }
      Τμήμα ALFA {
            \\ μια φορά ο κώδικας
            Διάβασε Α, Ν
            Τύπωσε Α*Ν
      }
}


Τύπωσε Α.Λ(10,20) \\ 200
Τύπωσε Α.L(10,20) \\ 200
Α.ALFA 10,4 \\ 40
Α.ΑΛΦΑ 10,4 \\ 40




Μπορούμε να πετύχουμε το παραπάνω επειδή στη Μ2000 οι παράμετροι μπαίνουν σε έναν σωρό τιμών. Όταν καλέσουμε τη συνάρτηση Λ τότε δημιουργείται ένας νέος σωρός και εκεί θα μπει στη κορυφή η τιμή 10 και αμέσως μετά η 20 (βάσει του παραδείγματος).  Η Λ όμως συνάρτηση καλεί την .LΛ() (η τελεία στην αρχή δηλώνει ότι είναι της ομάδας), σαν να ήταν τμήμα, σε ότι έχει να κάνει με το σωρό τιμών. Τα τμήματα μοιράζονται τον ίδιο σωρό αν βρίσκονται στην ίδια γραμμή συγγένειας.
Έτσι η Λ() και η LΛ() μέσω της ΚΑΛΕΣΕ μπήκαν σε ίδια γραμμή συγγένειας! Έτσι στη LΛ() βλέπουμε το σωρό της Λ() και κάνουμε αυτό που θέλουμε και βάζουμε πάλι στο σωρό την απάντηση με το ΒΑΛΕ. Δεν επιστρέφουμε τιμή με το = γιατί μη μηδενική τιμή είναι λάθος! (αυτό γίνεται για την Κάλεσε μόνο). Η δεύτερη εντολή της Λ() είναι το =Αριθμός. Η μεταβλητή Αριθμός  δίνει την κορυφή του σωρού τιμών αν είναι αριθμός, και τον βγάζει από εκεί, αλλιώς δίνει λάθος. Άρα δίνουμε τον αριθμό που έβαλε η LΛ(). Ο σωρός της Λ() στην επιστροφή θα πεταχτεί...και αν υπάρχουν τιμές θα διαγραφούν και αυτές. Αν θέλαμε να πάρουμε π.χ. έναν πίνακα τότε θα είχαμε μια Διάβασε Π() και μια =Π()  (δηλαδή θέλουμε αναγνωριστικό για σηκώσουμε το πίνακα). Όπως είναι η Αριθμός για τις αριθμητικές τιμές είναι και η Γράμμα$ για τα αλφαριθμητικά. Θα τις δείτε και στο πρόγραμμα παρακάτω!
Ο Σωρός Τιμών είναι μια ειδική λίστα, LIFO (Last In First Out) κατά κύριο λόγο αλλά μπορεί να χρησιμοποιηθεί ως FIFO (First In First Out), πάντα όμως παίρνουμε από την κορυφή. Με την Βάλε βάζουμε στη κορυφή (και η προηγούμενη πάει από κάτω), και με την Σειρά βάζουμε στο τέλος (άρα κάνουμε το FIFO). Κάθε φορά που καλούμε συνάρτηση ή τμήμα στο σωρό (νέο για τη συνάρτηση) μπαίνουν οι παράμετροι με συγχώνευση λίστας, ώστε η πρώτη αριστερά παράμετρος να είναι στη κορυφή ...και μετά τη τελευταία παράμετρο ακολουθεί ότι άλλο υπήρχε στο σωρό (αν είναι κλήση τμήματος, αλλιώς δεν έχει τίποτα).
Μπορούμε να βλέπουμε τι έχουμε στη κορυφή. Με την Ταύτιση( ) δίνουμε ένα αλφαριθμητικό όπου το πρώτο αριστερά γράμμα αντιστοιχεί στο τύπο της κορυφής. Με αυτό το τρόπο μπορούμε να ξέρουμε τι έχουμε στο σωρό πριν το "σηκώσουμε" με μια διάβασε. Το Α το ελληνικό σημαίνει αριθμός και το Γ σημαίνει γράμματα (Αλφαριθμητικό). Στην αγγλική έκδοση του προγράμματος έχω χρησιμοποιήσει τα N (Number) και S (String). Αυτός είναι ένας γρήγορος τρόπος. Υπάρχουν και άλλοι που θα δούμε σε άλλες αναρτήσεις!
Στο σωρό τιμών μπορούμε να βάζουμε αναφορές σε μεταβλητές, πίνακες, συναρτήσεις. Οι αναφορές είναι αλφαριθμητικά και την χρήση τους την κάνει η Διάβασε με το & πριν το όνομα (πρέπει να βάζουμε το ίδιο & και στην κλήση. Η εντολή ΚΑΝΕ φτιάχνει μια συνάρτηση απλά μας βολεύει εδώ γιατί μπαίνει σε μια γραμμή (δεν μπαίνει όμως σε ορισμό ομάδας-κλάσης)

Τμήμα ΑΑ {
      Διάβασε &Α()
      Τύπωσε Α(10)
}
Συνάρτηση Κ {
      =Αριθμός**2
}
Κάνε Χ(κ)=κ**3
ΑΑ &Κ()
ΑΑ &Χ()


Μπορούμε να αλλάζουμε κώδικα σε μια συνάρτηση ή ένα τμήμα μιας ομάδας. Αυτό συμβαίνει εδώ με το να δημιουργήσουμε μια ομάδα (εδώ ΚΚ) και να την συγχωνεύσουμε στο Αυτό, το αντικείμενο της κλάσης. Επειδή το όνομα είναι ίδιο...θα αντικατασταθεί ο ορισμός, διαφορετικά θα βάζαμε κάτι επιπλέον.
Κλάση α {
      Συνάρτηση Β {
      }
      Τμήμα α {
      Αν Αριθμός=1 τότε {
            Ομάδα ΚΚ {Συνάρτηση Β {=1000+Αριθμός}}
      } Αλλιώς {
            Ομάδα ΚΚ {Συνάρτηση Β {=2000+Αριθμός}}
      }
      Αυτό=ΚΚ
      }
}
αα=α(2)
Τύπωσε αα.β(10)
αα.α 1 \\ αλλάζει συνάρτηση
Τύπωσε αα.β(10)



Με τα παραπάνω είδαμε μερικές από τις δυνατότητες της Μ2000, που σίγουρα δεν τις βρίσκει κανείς σε μια απλή Basic. Πόσο μάλλον να βρει τρόπο να φτιάξει δυναμική δομή όπως αυτός εδώ ο πίνακας κατακερματισμού. Δείτε πως δεν έχουμε χρησιμοποιήσει δείκτες! Ούτε μπλεκόμαστε με αναφορές (δεν έχουμε πέρασμα με αναφορά εδώ). Έχουμε μια δυναμική δομή επειδή χρησιμοποιούμε αντικείμενα μέσα σε αντικείμενο. Όλη την δουλειά την κάνει ο διερμηνευτής της Μ2000!
Με την χρήση του Εγγράφου, του ειδικού τύπου μεταβλητής, έχουμε ταξινομημένα τα κλειδιά. Εδώ μπορούμε να κάνουμε μια δυαδική αναζήτηση αν θέλουμε να βρούμε το επόμενο στοιχείο, αλλά ουσιαστικά δεν μας ενδιαφέρει η σειρά. Μπορεί κανείς να κάνει με την FindIt συνεχόμενες αναζητήσεις, Δηλαδή αν το κλειδί περιλαμβάνει ένα επίθετο τότε μπορούμε να βρούμε όλες τις εγγραφές με αυτό το επίθετο. Να γιατί έχει και μια δεύτερη παράμετρο..και γιατί ακόμα μπορούμε να την καλέσουμε χωρίς παράμετρο (θα δώσουμε στην αρχή και μετά θα καλούμε μέχρι να μην βρει άλλο στοιχείο που να ταιριάζει με αυτό που ψάχνουμε). Ενώ λοιπόν η σειριακή αναζήτηση είναι αργή, με αυτόν τον τρόπο, ξεκινώντας από το τέλος της προηγούμενης αναζήτησης, έχουμε πολλαπλή αναζήτηση σε μια κατεύθυνση.
Διορθώθηκε και εδώ η FastExistItem()


Διάστιχο 0 : Window 12,0 : Διάστιχο 30 : Φόρμα 84 : Πένα 14 : Οθόνη 1 : Περιθώριο { Οθόνη 1 }
Ανανέωση
100
Αναφορά
2,"Hash Table ver2.0"
Διαμέσου
MyClass
Alfabeta=Hashtable(6)
Alfabeta.ItemNew "Zorro The Great", "data123456"
Alfabeta.ItemNew "Black Smith", "data1334245", "Alexander III", "data345678"
Alfabeta.ItemNew "Singer Sofia", "data1313113" , "Panatha Maria", "data234234"
Τύπωσε
"Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Black Smith")
Τύπωσε Φόρτος
Τύπωσε
Alfabeta.Item$("Panatha Maria")
Τύπωσε
"Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Alexander III")
Τύπωσε Φόρτος
\Διαμέσου CheckThis()
Διαμέσου
DisplayItem(0)
ok=Alfabeta.RemoveItem("Black Smith")
ok=Alfabeta.RemoveItem("Alexander III")
Διαμέσου
CheckThis()
Διαμέσου
DisplayItem(0)
Alfabeta.Item "Panatha Maria", "Hello There"
Διαμέσου
DisplayItem(0)
Τύπωσε
Alfabeta.FastExistItem("Panatha Maria")
Τύπωσε
Alfabeta.ExistItem("Panatha Maria")
Τέλος
Ρουτίνα
CheckThis()
      Τοπικές i
      Αναφορά Alfabeta.sort1$
      Για i=0 Έως Alfabeta.items-1 {
      Για alfabeta.data(i) {
          Τύπωσε i, .emp, .items,
          Αν Δεν .emp Τότε { Τύπωσε .i$(0,0) } Αλλιώς Τύπωσε
      }
      }
Τέλος Ρουτίνας
Ρουτίνα
DisplayItem(x)
      Τοπικές i,j, k$
      i=Alfabeta.Iterator()
      Τύπωσε @(x),"Items:"; i.itemmax
      Για Alfabeta {
            Ενώ i.NextItem() {
                  Aa$=i.key$()
                  k$=.Item$(Aa$)
                  j=.Hash(Aa$)
                  Τύπωσε @(x),i.item,") "+ Aa$, k$, j
            }
      }
Τέλος Ρουτίνας

MyClass: Κλάση HashTable {
      item_no, items
      lasts$, spos
      newkey=Αληθές
      Έγγραφο sort1$=""
      nl$={
      }
      Πίνακας data()
      Κλάση Item {
            Πίνακας i$(1)
            items=0, LastId, Emp=Αληθές
            Τμήμα AddItem {
                  Πίνακας .i$(.items+1, 2)
                  Διάβασε .i$(.items,0), .i$(.items,1)
                  .items++
                  .Emp<=Ψευδές
            }
            Συνάρτηση FindIt {
                  Διάβασε anykey$
                  Αν .Emp Τότε Έξοδος
                  = Ψευδές
                  Για .Lastid<=.items-1 Έως 0 {
                        Αν .i$(.Lastid,0)=anykey$ Τότε =Αληθές : Έξοδος
                  }
            }
            Συνάρτηση Value$ {
                  Αν .Emp Τότε Λάθος 10030
                  =.i$(.Lastid,1)
            }
            Τμήμα Delone {
                  Αν .lastid<=.items-2 Τότε {
                    Στοκ .i$(.lastid+1,0) Για (.items-.lastid-1)*2, .i$(.lastid,0)
                  }
                  .items--
                  Αν .items=0 Τότε {
                        .emp<=Αληθές
                        Πίνακας .i$()
                  } Αλλιώς Πίνακας .i$(.items, 2)
            }
      }
      Τμήμα HashTable {
            Διάβασε .items
            A=.Item()
            Καθαρό .sort1$
            Πίνακας .data(.items)=A
      }
      Συνάρτηση F {
            Διάβασε A, b
            b+=A*1024+A
            Βάλε Δυαδικό.Από(b,0X83F3Cf)
      }
      Συνάρτηση Hash {
            Διάβασε Alfabeta$
            Βάλε 0
            Για i=1 Έως len(Alfabeta$)
                  Κάλεσε .F(χαρκωδ(μεσ$(Alfabeta$,i)))
            Επόμενο i
            =Δυαδικό.Η(Αριθμός, 0XAFFA0000+i*.items) υπόλοιπο .items
      }
      Τμήμα Item {
            .newkey<=Ψευδές
            .ItemNew
            .newkey<=Αληθές
      }
      Τμήμα ItemNew {
            Ενώ Ταύτιση("ΓΓ") {
            Διάβασε name$, data$
            name$=Κεφ$(name$)
            i=.Hash(name$)
                  Για Αυτό, this.data(i) {
                        Αν ..Findit(name$) Τότε {
                              Αν .newkey Τότε Λάθος 10010
                              ..i$(..lastid,1)=data$
                        } Αλλιώς {
                        ..AddItem name$, data$
                        .sort1$<=name$+.nl$ : Ταξινόμηση .sort1$,1, Εγγράφου.παρ(.sort1$)-1
                        }
                  }
            }
      }
      Συνάρτηση Item$ {
            Διάβασε name$
            name$=Κεφ$(name$)
            Για .data(.Hash(name$)) {
                  Αν Δεν .Findit(name$) Τότε Λάθος 10020
                  =.value$()
            }
      }
      Συνάρτηση FastExistItem {
            Πάνω
            =.data(.Hash(Κεφ$(Γράμμα$))).Findit(Κεφ$(Γράμμα$))
      }
      Συνάρτηση ExistItem {
            Αν Ταύτιση("Γ") Τότε {
                  Διάβασε .lasts$
                  .lasts$ <= Κεφ$(.lasts$)
                  .spos<=1
            }
            Find .sort1$, .lasts$, .spos
            Διάβασε .spos
            Αν .spos=0 Αλλιώς {
                  Διάβασε .item_no, c
                  Αν Ταύτιση("Α") Τότε { Διάβασε ok } Αλλιώς ok=Ψευδές
                  Αν ok Τότε {
                  .spos++ : =Αληθές
                   } Αλλιώς {
                  Αν c=1 Τότε .spos++ : =Αληθές
                  }
            }      
      }
      Συνάρτηση ItemKey$ {
            Διάβασε No
            =Παράγραφος$(.sort1$,No)
      }
      Συνάρτηση ValidItems {
            =Εγγράφου.παρ(.sort1$)-1
      }
      Συνάρτηση Iterator {
            Ομάδα aa {
                  item, itemmax
                  ref$
                  Συνάρτηση nextitem {
                        .item++
                        =.item<=.itemmax
                  }
                  Συνάρτηση key$ {
                        Αν .item=0 Τότε Λάθος 101010
                       = Συνάρτηση$(.ref$.ItemKey$(), .item)
                  }     
            }
            aa.itemmax=.ValidItems()
            aa.ref$=&Αυτό
            =aa
      }       
      Συνάρτηση RemoveItem {
            Διάβασε Alfabeta$
            Alfabeta$=Κεφ$(Alfabeta$)
            Αν .ExistItem(Alfabeta$) Τότε {
                  oldvalue$=Παράγραφος$( .sort1$, .item_no, -1) ' διαγράφουμε γραμμή
                  Για .data(.Hash(Alfabeta$)) {
                        Αν Δεν .Findit(Alfabeta$) Τότε Έξοδος
                        .delone
                        =Αληθές
                   }
             }
       }            
} Επιστροφή
   

Δεν υπάρχουν σχόλια:

Δημοσίευση σχολίου