Σάββατο, 29 Απριλίου 2017

Αναθεώρηση 16 (Έκδοση 8.7) - Προσθήκη Επεξηγήσεων!

Βελτιώθηκε η ταχύτητα στο χειρισμό των αντικειμένων.
Εδώ έχουμε μια κλάση, που παράγει αντικείμενα. Το τμήμα Class: δεν θα περάσει στις παρουσίες των αντικειμένων.
Χρησιμοποιούμε ένα αντικείμενο Σωρός (ειδική στοίβα) και εκεί βάζουμε μερικά αντικείμενα. Έχουμε δυο ρουτίνες ταξινόμησης, μια Selection Sort  ή ταξινόμηση με επιλογή (εδώ την λέμε StackSort) και η άλλη είναι η quicksort.
Στην πρώτη ρουτίνα ταξινόμησης χρησιμοποιείται σωρός με επισροφές τιμών απευθείας σε στοιχεία. Ο σωρός είναι συνδεδεμένη λίστα, και κανονικά με την Βάλε ή Push βάζουμε στη κορυφή και με την Σειρά ή Data βάζουμε στο πυθμένα. Η Διάβασε ή Read διαβάζει πάντα από την κορυφή (και πετάει την τιμή)
Με την χρήση του StackItem() ή ΤιμήΣωρού()  (και StackItem$() ή ΤιμήΣωρού$() για αλφαριθμητικά), διαβάζουμε χωρίς να πετάμε τιμές. Αν θέλουμε μπορούμε με την Επιστροφή να επιστρέψουμε τιμές σε θέσεις (να τις αλλάξουμε δηλαδή). Η εντολή επιστροφή αλλάζει πολλές τιμές αν θέλουμε (παίρνει λίστα). Δείτε όμως ότι για να λειτουργήσει θέλει δείκτη σε σωρό. Μπορούμε να πάρουμε τον τρέχον σωρό σε ένα δείκτη με αυτό Αλφα=[]  (το [] είναι ο τρέχον σωρός), και ο τρέχον σωρός θα αδειάσει. Μπορούμε να επιστρέψουμε τις τιμές από το Αλφα με την Σωρός Άλφα (θα μπούνε οι τιμές στο τέλος του σωρού, οπότε αν είναι άδειος ο τρέχουν θα έχει τις τιμές του Άλφα, και ο Άλφα θα αδειάσει).






Class M {
       x=10, y=30
      Function comp (mm) {
            = Compare(.x,mm.x)
      }
      operator ">"  (mm) {
            Push .x>mm.x
      }
      value {
            =.x*.y
      }
Class:
      Module M (.x,.y) {}
}
N=Stack:=M(10,30), M(4,15), M(50,60),M(3,15), M(33,16), M(34,15), M(33,16), M(4,15), M(10,30), M(54,15), M(50,60),M(13,15), M(33,16), M(124,15) , M(10,30), M(4,15), M(50,60),M(13,15), M(33,16), M(4,15), M(33,16), M(4,15), M(10,30), M(54,15), M(50,60),M(23,15), M(33,16), M(24,15)
Inventory Const="Ascending":=1, "Descending":=-1
Profiler
If Len(N)>1 then SortStack(each(N, 1, Len(N)-1),Const("Ascending"))
Print timecount
Print "Press Any Key, for list - sorted by second column from left"

A$=Key$
Print "xxxxxxxxxxxxxxxxxxxxxxxxxxXXXXxxxXXXXxxxxxxxx"
ShowN(Each(N))

N=Stack:=M(10,30), M(4,15), M(50,60),M(3,15), M(33,16), M(34,15), M(33,16), M(4,15), M(10,30), M(54,15), M(50,60),M(13,15), M(33,16), M(124,15) , M(10,30), M(4,15), M(50,60),M(13,15), M(33,16), M(4,15), M(33,16), M(4,15), M(10,30), M(54,15), M(50,60),M(23,15), M(33,16), M(24,15)
Profiler
Stack N {
      quicksort(1, Len(N), Const("Ascending"))
}
Print timecount
Print "Press Any Key, for list - sorted by second column from left"

A$=Key$
Print "xxxxxxxxxxxxxxxxxxxxxxxxxxXXXXxxxXXXXxxxxxxxx"
ShowN(Each(N))
Sub SortStack(Nrep1, cc)
While Nrep1 {
      Nrep2=Each(Nrep1, Nrep1^+1)
            Let temp1=stackitem(Nrep1)
            ok=FALSE
            While Nrep2 {
                              let temp2=stackitem(Nrep2)
                              If compare(temp1.x,temp2.x)=cc then {
                              return Nrep2, Nrep2^+1:=Group(temp1)
                              let temp1=group(temp2)
                              ok=TRUE
            }
           If ok then return Nrep1, Nrep1^+1:=Group(temp1)
      }
}
End Sub
Sub ShowN(Nrep)
      While Nrep {
                 Let temp=stackitem(Nrep)
                  Print temp, temp.x, temp.y, Nrep^+1
      }
End Sub
Sub quicksort(first, last, cc)
      Local thing(1), i=first, Limit=last+1
      If Limit >2 Then Shift (Limit+i) Div 2
      Read thing(0)
      Limit--
      For thing(0) {
            While i<Limit {
                  If .comp(stackitem(i))=-cc then {
                        Limit--
                        If i>1 Then Shift i
                        ShiftBack Limit
                  }  Else i++
            }
            If i>Limit Then i=Limit
            Push group(This)
            }
     dim thing()
      ShiftBack i
      If i>first Then quicksort(first,i-1, cc)
      If last>i Then quicksort(i,last, cc)
End Sub


Μια εξήγηση για το thing(1) και λίγα λόγια για τα αντικείμενα.  Εκτός από την Πϊνακας (Dim) για να ορίσουμε πίνακες μπορούμε να ορίζουμε και με την Local (Τοπική ή Τοπικές) ή και την Global (Γενική ή Γενικές). Δεν έχουμε όμως τα ίδια επιπλέον που μας δίνει η Πίνακας (πχ την αλλαγή βάσης), αλλά μπορούμε εκ των υστέρων να την χρησιμοποιήσουμε (όταν θα υπάρχει ήδη το αντικείμενο - εσωτερικά οι πίνακες είναι αντικείμενα στη Μ2000).
Εδώ στην quicksort θέλουμε να διαβάσουμε το αντικείμενο σε θέση πίνακα. Όταν γίνεται αυτό το αντικείμενο είναι κλειστό, δηλαδή περιέχει οτιδήποτε μόνο για το ίδιο. Αν το διαβάσουμε με όνομα, τότε δημιουργείται το λεγόμενο ανοικτό και όλα τα μέλη γίνονται ταυτόχρονα μέλη του τμήματος που διαβάστηκε (οι ρουτίνες είναι μέρος του τμήματος, στο οποίο ότι δημιουργούμε διαγράφεται). Επειδή θέλουμε να καλέσουμε με αναδρομή την quicksort μας βολεύει το αντικείμενο να μην παίρνει χώρο στις λίστες μεταβλητών/συναρτήσεων, ως ανοικτό, και να ανοίγει μόνο όταν χρειάζεται. Το πρόσκαιρο άνοιγμα το κάνει η For thing(0) { } και έτσι εντός του μπλοκ το .comp() σχετίζεται με αυτό το αντικείμενο.
Η δυσκολία (που δεν φαίνεται με μια ματιά) βρίσκεται στο ότι έχουμε το αντικείμενο έτσι φτιαγμένο ώστε να γυρνάει τιμή (το Χ*Υ). Η Stackitem() όμως δεν γυρνάει τιμή αλλά ένα αντίγραφο του αντικειμένου (δεν δίνει δείκτη στο αντικείμενο ομάδα, ενώ σε άλλα αντικείμενα που τα χρησιμοποιούμε με δείκτη προς αυτά όντως δίνει δείκτη).
Επειδή βγάζουμε από την λίστα (σωρός τιμών) ένα αντικείμενο και το βάζουμε στην Thing(0) (ένα στοιχείο, με βάση το 0, άρα θα είναι στην θέση 0), θα πρέπει να το βάλουμε πάλι στη θέση του. Αν κάναμε αυτό Βάλε Thing(0) θα έδινε την τιμή X*Y και όχι το αντικείμενο. Η Ομάδα() ή Group() θέλει ένα ανοικτό αντικείμενο και αφού το βρει δίνει το αντίγραφό του σε κλειστό (μαζεύει ότι έχει μέσα στο χώρο του αντικειμένου, ενώ στο ανοικτό, ο χώρος του αντικειμένου είναι μια λίστα με ονόματα και θέσεις στο χώρο μεταβλητών/συναρτήσεων, χωρίς τιμές). Δίνουμε το This (Αυτό) που ο διερμηνευτής γνωρίζει ότι είναι το ανοικτό αντικείμενο που έβγαλε η For Thing(0) { }. Θα μπορούσαμε να τo περάσουμε και με  αναφορά πχ Τμήμα1 &Αυτό σε ένα τμήμα Τμήμα1 (αρκεί εκεί να υπάρχει η Διάβασε &έναόνομα). Έτσι βάζουμε στο σωρό το Group(This) με την Push Group(This), ως αντίγραφο του This. Μόλις τερματίσει το μπλοκ For Thing(0) { } αυτόματα ξανακλείνει το αντικείμενο, πετάει το παλιό στο Thing(0) και βάζει το νέο (στο πίνακα έχουμε Variant γιατί αυτός ο τύπος μπορεί να πάρει δείκτες προς αντικείμενα, αλλά και τιμές όπως double ή τύπου string).
Αν έχουμε βάθος κλήσεων έστω 10 στην quicksort (την ρουτίνα όπως έχουμε εδώ) τότε το τμήμα θα έχει δέκα πίνακες Thing(0) και ο ενεργός θα είναι ο τελευταίος. Κάθε φορά που κάνουμε επιστροφή από την ρουτίνα, καθαρίζονται οι λίστες μεταβλητών/συναρτήσεων, στο σημείο που ήταν πριν την κλήση.
Η Μ2000 δεν τοποθετεί τις μεταβλητές και τις συναρτήσεις στην στοίβα εκτέλεσης. Οι λίστες μεταβλητών και συναρτήσεων είναι δυναμικοί πίνακες με λειτουργία συνάρτησης κατακερματισμού (για να βρίσκει γρήγορα τα ονόματα), με την ιδιομορφία να αυξομειώνονται (όχι υποχρεωτικά και ο χώρος τους κάθε φορά), πάντα από το τέλος, το πιο πρόσφατο, και να περιέχουν ίδια κλειδιά (ίδια αναγνωριστικά). Με αυτόν τον τρόπο πετυχαίνεται η σκίαση μεταβλητών. Το πραγματικό όνομα μιας μεταβλητής έχει να κάνει με το όνομα που βλέπουμε και το πρόθεμα που παίρνουν από το τμήμα που βρίσκονται. Δεν μας απασχολεί αυτό, αφού δουλεύει, αλλά έχει σημασία να γνωρίζουμε ότι αντικείμενα που είναι σε πίνακες έχουν κρυφό όνομα που αποδίδεται από το σύστημα όταν ανοίγουν. Το άνοιγμα σημαίνει να περαστούν τα ονόματα μεταβητών/συναρτήσρων στις λίστες ώστε να μπορούν να χρησιμοποιηθούν. Εδώ δεν έχουμε κάποια διεπαφή (interface) να παίρνει το όνομα της συνάρτησης της ομάδας και να το αναζητεί σε αυτό, αλλά απευθείας καλείται η συνάρτηση ως υπάρχουσα σαν όλες τις άλλες. Στην κλήση όμως η συνάρτηση ενημερώνει ότι ανήκει σε αντικείμενο με συγκεκριμένο πρόθεμα, οπότε οι μεταβλητές .Χ και .Υ θα πάρουν το σωστό πρόθεμα (και θα βρεθούν άμεσα στη λίστα μεταβλητών). Έτσι οι ομάδες (Groups) στην M2000 δεν έχουν Διεπαφή/interface, ξεχωριστό από το χρήστη, παρά μόνο ένα βασικό (υποχρεωτικά) που διαχειρίζεται εσωτερικά ο διερμηνευτής. Οι κλάσεις είναι συναρτήσεις που παράγουν ομάδες. Έτσι υπάρχει η νοητή διεπαφή, τα μέλη της ομάδας. Θα βγει λάθος κατά την εκτέλεση αν ζητάμε ένα μέλος που δεν υπάρχει. Οι ομάδες μπορούν να αυξάνουν τα μέλη τους, ενώ δεν υπάρχει διαγραφή μελών. Αυτό που υπάρχει είναι η συγχώνευση,  δηλαδή έχουμε μια ομάδα Α και θέλουμε να έχει επιπλέον τα μέλη της Β, μπορούμε με το Α=Β να δώσουμε αντίγραφο μελών του Β στο Α (αν το Β και το Α δεν έχουν Αξίες, δεν λειτουργούν ως μεταβλητές με τιμές αριθμητικές ή αλφαριθμητικές). Ή μπορούμε να έχουμε μια νέα ομάδα Ζ και σε αυτήν να βάλουμε το Ομαδα(Α) και Ομάδα(Β), διαδοχικά: Ζ=Ομάδα(Α) και Ζ=Ομάδα(Β), και έτσι θα έχουμε την Ομάδα Ζ με τα μέλη του Α και του Β (αν το Β έχει κάποια ίδια μέλη με το Α τότε το Ζ θα εχει μια φορά αυτά τα μέλη με τις τελευταίες τιμές, αυτές του Β). Επειδή η Μ2000 έχει την δυνατότητα δημιουργίας πρόσκαιρων ορισμών, τόσο ως τοπικές σε  τμήμα/συνάρτηση/ρουτίνα όσο και στα μπλοκ με Για αντικείμενο { } (και σαν γενική μορφή υπάρχει το Για Αυτό { }) να έχουμε ομάδες όπως η Ζ να εξυπηρετούν το σκοπό μας και μετά βάζουμε στο Α ας πούμε ένα τμήμα που θα διαβάζει με αναφορά το Ζ και θα παίρνει τις νέες τιμές που θέλουμε να κρατήσουμε μετά τη διαγραφή του (το Ζ ας πούμε είναι προσωρινό).
Με την συγχώνευση μελών η Μ2000 πετυχαίνει να δημιουργεί ομάδες από άλλες ομάδες, άρα κατά μια έννοια να προσθέτει λειτουργικότητα. Στη Μ2000 όπως μπορούμε να έχουμε τμήματα/συναρτήσεις/ρουτίνες σε τμήματα/συναρτήσεις, και τμήματα/συναρτήσεις σε ρουτίνες (μπορούμε να έχουμε ρουτίνες σε ρουτίνες, αλλά στην ουσία δεν έχει νόημα αφού οι ρουτίνες έχουν θέαση σε όλο το τμήμα απ όπου καλούνται, άρα κάπου θα βρούμε χώρο να βάλουμε κάποιες άλλες και όχι ειδικά μέσα σε μια ρουτίνα), έτσι και στις ομάδες μπορούμε να έχουμε ένα δένδρο ομάδων (μπορούμε να κάνουμε συγχωνεύσεις σε ομάδες που βρίσκονται σε άλλες ομάδες, αρκεί να μην γυρνούν ή δέχονται τιμή ως μεταβλητές). Μια ομάδα μπορεί να έχει οτιδήποτε εκτός από ρουτίνες (ρουτίνες μόνο τα τμήματα και οι συναρτήσεις έχουν, και αυτά όμως που βρίσκονται σε ομάδες). Μπορούμε ακόμα να έχουμε κλάσεις σε ομάδες, για να δημιουργούν δικές τους ομάδες (οι ομάδες επιστρέφονται ως κλειστά αντικείμενα και από συναρτήσεις, αλλά τοποθετούνται σε πίνακες, καταστάσεις  (λίστες με κλειδί) και σωρούς (ειδικές στοίβες τύπου συνδεδεμένης λίστας σε μια απλή διάταξη γραμμής, όπου η μετακίνηση θέσης είναι ανέξοδη, σε χρόνο και πόρους)
Αξίζει να αναφερθεί ότι μπορούμε σε κάθε θέση σε πίνακα, κατάσταση, σωρό να έχουμε οτιδήποτε. Ένας πίνακας δηλαδή μπορεί να έχει στις θέσεις του άλλους πίνακες και αυτοί να έχουν σωρούς, και οι σωροί να έχουν ομάδες. 'Η να έχουμε πίνακες με καταστάσεις (δουλεύουν με πίνακα κατακερματισμού, άρα με γρήγορη αναζήτηση) και σε κάθε στοιχείο κατάσταση να έχουμε πίνακα ή σωρό ή άλλη κατάσταση.
Τα αντικείμενα σωρός, κατάσταση, και ο λεγόμενος αυτόματος πίνακας (είδος πίνακα) δουλεύονται με δείκτη (αλλά στην τιμή του δεν έχουμε πρόσβαση), αλλά μεταβιβάζεται. Αυτό σημαίνει όμως ότι μπορεί μια κατάσταση Α να έχει σε στοιχείο της δείκτη στον εαυτό της ή σε άλλη Β όπου εκεί να υπάρχει δείκτης στην Α. Για το λόγο αυτό υπάρχει σύστημα που γνωρίζει πώς θα "Σκουπίσει" στη περίπτωση διαγραφής (σε προσωρινές-τοπικές), και αυτό λέγεται συλλέκτης σκουπιδιών. Η εντολή Λίστα αναφέρει αν υπάρχουν αντικείμενα με πολλαπλούς δείκτες προς αυτά. Ο καθαρισμός γίνεται αυτόματα, αλλά γίνεται και με το Clear ή Καθαρό που σβήνει μεταβλητές και κάνει και έλεγχο για καθαρισμό (αν χρειάζεται).






Αναθεώρηση 15 (Έκδοση 8.7)

Σε αυτήν την αναθεώρηση διόρθωσα ένα λάθος στην ένωση πινάκων. Η ένωση δούλευε για μονοδιάστατους αλλά όχι σε περίπτωση που ο πρώτος στην ένωση ήταν με δυο ή περισσότερες διαστάσεις. Σε Wine (Linux) προκαλούσε άμεση διακοπή του διερμηνευτή, ενώ σε Windows απλά δεν έκανε την ένωση (προφανώς στο Wine δεν γίνεται καλό exception handling)

Στα αγγλικά η ένωση είναι το cons() (το έχω πάρει από την Lisp).
Στα ελληνικά είναι ένωση()


dim a(2,5)=10, b()
b()=a()
b=b()
b-=5
Print b()
Print
Print b
Print
Print Dimension(a()) ' 2
a()=cons(b(),a())
Print Dimension(a()) ' 1
dim a(2,10)
Print Dimension(a()) ' 2
Print a()

Απλά Μικρά Προγράμματα


Τα παρακάτω προγράμματα τα γράφουμε σε ένα τμήμα έστω Α και τα εκτελούμε με το όνομα του τμήματος.

Εισαγωγή Αριθμών με Δημιουργία Μεταβλητών

Εισαγωγή "Δώσε α , β: ", α, β
Τύπωσε "άθροισμα α+β="; α+β
Μπορούμε να δώσουμε και αριθμούς με δεκαδικά. Με την τελεία δίνουμε το σημείο δεκαδικών, μπορεί να είναι κόμμα ή τελεία. Με το κόμμα ή το Enter πάμε στην επόμενη εισαγωγή.

Εισαγωγή Ακεραίων Αριθμών με Δημιουργία Μεταβλητών

Εισαγωγή "Δώσε α , β: ", α%, β%
Τύπωσε "άθροισμα α+β="; α%+β%
Λίστα
Η εντολή Λίστα θα μας δείξει
τις μεταβλητές, με ! αμέσως μετά θα δείξει τις μεταβλητές με χρήση αναλογικής γραφής. (δοκιμάστε το Λίστα !)

Πράξεις με ακέραιες τιμές

Μ=1.3343
Τύπωσε Ακ(Μ) 'δίνει 1
Ζ=1.889
Τύπωσε Ακ(Ζ) ' δίνει 1
Τύπωσε Δεκ(Ζ) ' δίνει .889
Τύπωσε Στρογγ(Ζ,0) ' δίνει 2
Τύπωσε Στρογγ(Ζ,1) ' δίνει 1.9
Τύπωσε Στρογγ(Ζ,2) ' δίνει 1.89
Τύπωσε Στρογγ(-Ζ,2) ' δίνει -1.89
Τύπωσε Στρογγ(-Ζ,0) ' δίνει -2
Τύπωσε Ακ(-Ζ) 'δίνει -2, τον αμέσως κοντινότερο ακέραιο προς τα κάτω

Τύπωσε 5 δια 1.5 ' δίνει 5 γιατί πρώτα κάνει ακέραια την 1.5
Τύπωσε 6 δια -1.5 ' δίνει -3 γιατί κάνει το Ακ(-1.5) άρα το -2
Τύπωσε 7 υπόλ 2 ' δίνει  1
Τύπωσε 7 υπόλ -2 ' δίνει  1  
Τύπωσε -7 υπόλ 2 ' δίνει  -1



Και οι ακέραιες μεταβλητές και οι πραγματικές (κινητής υποδιαστολής) εσωτερικά είναι ίδιου τύπου (double, πραγματικές). Οι τελεστές Δια και Υπόλ (υπάρχει και ως Υπόλοιπο) δουλεύουν με πραγματικές και αφαιρούν τα δεκαδικά. Η Υπόλ ή Υπόλοιπο αφαιρεί και το πρόσημο στο διαιρέτη. Οι εντολές μπορούν να γραφούν με πεζά ή κεφαλαία, με τόνους ή χωρίς (και λάθος τόνος δεν μας πειράζει, ο διερμηνευτής αφαιρεί τους τόνους στα ελληνικά κατά την εκτέλεση)


Στις συγκρίσεις το διπλό ίσον == κάνει πρώτα στρογγυλοποίηση στις τιμές που θα συγκρίνει στο 13ο δεκαδικό, ενώ το απλό δεν κάνει καμία στρογγυλοποίηση.

Επανάληψη εντολών με μετρητή και βήμα

Για ι=1 έως 1000 ανά 2 {
      Τύπωσε ι,
}
Τύπωσε

Για ι=1000 έως 1 ανά 2 {
      Τύπωσε ι,
}
Τύπωσε
Στη Μ2000 αν η αρχή είναι μεγαλύτερη από το τέλος της μέτρησης, τότε κατεβαίνει ο μετρητής. Το όριο τέλους μετράει για την εκτέλεση του μπλοκ εντολών. Το βήμα είναι θετικό.
Το ι θα πάρει μετά το πέρας της επανάληψης/μέτρησης την επόμενη τιμή εκτός ορίου


Για ι=1 εως 1 ανά -1 {
      Τύπωσε ι \\ δίνει 1
}
Τύπωσε ι \\ δίνει 0


Υπάρχει μια περίπτωση που το βήμα μας ενδιαφέρει αν είναι θετικό ή αρνητικό, όταν έχουμε αρχή και τέλος ίδιο όριο. Τότε ο διερμηνευτής αποφασίζει ποια θα είναι η τιμή μετά το πέρας της επανάληψης (μια φορά θα εκτελεστεί το μπλοκ εντολών), και αλλάζει ανάλογα την τιμή του μετρητή.
Για ι=1 εως 1 ανά -1 {
      Τύπωσε ι \\ δίνει 1
}
Τύπωσε ι \\ δίνει 0


Μπορούμε να χρησιμοποιούμε αριθμούς με δεκαδικά, και βήμα με δεκαδικά.
Για ι=1.5 έως 10 ανά .3 {
      Τύπωσε ι,
}
Τύπωσε


Θα μας δώσει αυτό: 1.5, 1.8, 2.1, 2.4, 2.7, 3, 3.3, 3.6, 3.9, 4.2, 4.5, 4.8, 5.1, 5.4, 5.7, 6, 6.3, 6.6, 6.9, 7.2, 7.5, 7.8, 8.1, 8.4, 8.7, 9, 9.3, 9.6, 9.9

Εξαγωγή στο Πρόχειρο

Ο κώδικας για να μας κάνει εξαγωγή τα παραπάνω νούμερα στο πρόχειρο είναι αυτός:
Έγγραφο Ν$="1.5"
Για ι=1.8 έως 10 ανά .3 {
     Ν$=", "+Γραφη$(ι,"")
}
Πρόχειρο Ν$


Το έγγραφο παίρνει ότι δίνουμε και το βάζει στο τέλος. Έχει πολλές χρήσεις που θα δούμε αργότερα. Όταν διαβάζουμε όμως τιμή διαβάζεται ως αλφαριθμητικό (εκτός από ειδικές συναρτήσεις που αναγνωρίζουν ότι είναι αντικείμενο).


Αλφαριθμητικά Πολλαπλών Παραγράφων



\\ μπορούμε να δίνουμε αλφαριθμητικά πολλαπλών γραμμών
\\ η θέση του τελευταίου άγκιστρου δηλώνει πόσα κενά θα αφαιρεθούν
\\ από την δεύτερη παράγραφο και κάτω

Ν$={Κείμενο, Πρώτη παράγραφος
      Δεύτερη παράγραφος
      Τρίτη παράγραφος
      }
Αναφορά Ν$
Έγγραφο Ν$ ' αναβάθμιση σε Έγγραφο
Αναφορά Παραγραφος$(Ν$, 2)
Αναφορά Παραγραφος$(Ν$, 1)
\\ Αφαιρούμε τη δεύτερη παράγραφο
\\ ενώ μας την δίνει σε μια μεταβλητή αλφαριθμητική
παλιάπαράγραφος$=Παράγραφος$(Ν$,2,-1)
Αναφορά Ν$
\\ βάζουμε και μια αλλαγή γραμμής
Ν$=παλιάπαράγραφος$+{
}
Ν$=παλιάπαράγραφος$
Αναφορά Ν$


Μορφή Για/Επομενο

Για ι=10 έως 1 ανά 2
      Τύπωσε ι,
Επόμενο ι
Τύπωσε
Υπάρχει και η μορφή που ταιριάζει με την Basic (αλλά και εδώ τα όρια δηλώνουν την κατεύθυνση της μέτρησης, ενώ στην Basic πρέπει να δοθεί αρνητικό βήμα. Αν δώσουμε και εδώ -2, ο διερμηνευτής θα εξάγει το απόλυτο νούμερο (χωρίς το πρόσημο). Χρησιμοποιεί το πρόσημο μόνο αν έχουμε ίσα όρια.

Χρήση συνθήκης για επανάληψη με την Ενώ

Στην Ενώ συνθήκη { } υπάρχει περίπτωση να μην εκτελεστεί ποτέ το μπλοκ. Αυτό συμβαίνει αν δεν γίνει η συνθήκη αληθής.


Κ=3
Ενώ Κ<10 {
      Τύπωσε Κ
      Κ++
}


Λ=5
Κ=3
Ενώ Κ<10 και Λ>3 {
      Τύπωσε Κ
      Κ++
      Λ-=.8
}


Οι πράξεις γίνονται με πραγματικούς αριθμούς, ακόμα και αν βάλουμε μεταβλητή ακέραια (με % στο όνομα). Αποθηκεύονται τα αποτελέσματα ως ακέραια μόνο αν τα καταχωρούμε σε ακέραιες μεταβλητές ή τα περάσουμε από την Ακ()


Χρήση συνθήκης για επανάληψη τύπου Επανέλαβε/Μέχρι



Δ=0
Α=-10
Επανέλαβε {
      Α++
      Δ=Τυχαίος(1,5)
      Τύπωσε Α*Δ,
} Μέχρι Α>5 ή Δ=3
Τύπωσε


Η εντολή Επανέλαβε υπάρχει και σαν Επανάλαβε

Χρήση Αν συνθήκης Τότε σε επανάληψη τύπου Επανέλαβε/Πάντα



Δ=0
Α=-10
Επανέλαβε {
      Α++
      Δ=Τυχαίος(1,5)
      Αν Δ=3 Τότε Έξοδος
      Τύπωσε Α*Δ,
      Αν Α>5 Τότε Έξοδος
} Πάντα
Τύπωσε


Χρήση Τυχαίων με πρόσκαιρη δημιουργία τυχαίων βάσει μιας αρχής.



Με την εντολή Ν=Τυχαίος(!4567) θέτουμε τη γεννήτρια τυχαίων αριθμών από ένα σημείο που θα δώσει την ίδια σειρά αριθμών. Υπάρχει η δυνατότητα να κόψουμε πρόσκαιρα τη ροή τυχαίων, να τη βάλουμε σε μια ροή γνωστή και να γυρίσουμε στην προηγούμενη ροή (δεν κρατάει πάνω από ένα κόψιμο το σύστημα).


Το παρακάτω πρόγραμμα δίνει τρεις τυχαίους, μετά άλλους τρεις που ξεκινούν από καθορισμένο σημείο και μετά συνεχίζει από το προηγούμενο.
Το δεύτερο μέρος είναι οι αριθμοί χωρίς τους ενδιάμεσους τρεις:


Ν=Τυχαίος(!1983874)
Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος
Ν=Τυχαίος(!19742323)
Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος
Ν=Τυχαίος(!)
Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος

\\ χωρίς την προσωρινή αλλαγή
Ν=Τυχαίος(!1983874)
Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος
\\Ν=Τυχαίος(!19742323)
\\Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος
\\Ν=Τυχαίος(!)
Τύπωσε Τυχαίος, Τυχαίος, Τυχαίος


Η Τυχαίος δίνει έναν δεκαδικό αριθμό μη μηδενικό ακέραιο μέρος, ενώ η Τυχαίος(1, 5) θα δώσει έναν από τους 1,2,3,4,5. Αν δώσουμε τιμές με δεκαδικά στην Τυχαίος() αυτή θα πάρει τις τιμές ως ακέραιους (θα εκτελέσει το Ακ() εσωτερικά).

Γέμισμα πίνακα με τυχαίους αριθμούς και μέτρηση συχν. Εμφάνισης


Θα γεμίσουμε έναν πίνακα με τιμές από 1 έως 8 και θα μετρήσουμε πόσες φορές κάθε νούμερο υπάρχει στο πίνακα. Η συχνότητα εμφάνισης είναι ο λόγος πόσες φορές εμφανίζεται στο σύνολο των αριθμών (μέτρηση για το καθένα ξεχωριστό αριθμό προς συνολικό αριθμό)
Στο παράδειγμα ορίζουμε ότι η βάση των πινάκων θα είναι το 0 (Αυτό είναι εξ ορισμού). Μπορούμε όμως να ορίσουμε κάποιο πίνακα με βάση το 1 ειδικά για αυτόν (ομοίως αν είχαμε το 1 για όλους τους πίνακες).
Το γέμισμα του πίνακα γίνεται με το τελεστή << ο οποίος εκτελείται για κάθε στοιχείο, εδώ εκτελούμε την Τυχαίος(1,8) για κάθε στοιχείο.
Η μεταβλητή Ν κρατάει το νούμερο στοιχείων. Όσο μεγαλύτερη είναι η Ν τόσο στρώνουν οι συχνότητες.
Εδώ στο παράδειγμα ξεκινάμε με Ν=20000, δηλαδή θα φτιάξουμε έναν πίνακα με 20 χιλιάδες αριθμούς (η μνήμη που θα χρειαστεί είναι 12*20000 ή 234,375 kBytes). Κανονικά ο double θέλει 8 Bytes αλλά οι πίνακες της Μ2000 κρατούν εσωτερικά Variant (12 Bytes), για σκοπό που δεν γίνεται τώρα φανερός!
Βάση 0
Ν=20000
Πίνακας Α(Ν)<<Τυχαίος(1,8)
Πίνακας Βάση 1, Μετρ(8)
Για ι=0 έως Ν-1 {
      Μετρ(Α(ι))++
}
Για ι=1 έως 8 {
      Τύπωσε Μορφή$("Το {0} έχει συχνότητα {1:2}%",ι,Μετρ(ι)/Ν*100)
}

Ο τελεστής ++ αυξάνει κατά ένα το στοιχείο Α(ι) του πίνακα Μετρ(). Ξέρουμε ότι οι τιμές στον Α(ι) είναι από 1 έως 8, οπότε δεν θα προκύψει λάθος δείκτη. Η Μ2000 ελέγχει κάθε φορά αν ο δείκτης είναι εκτός ορίων.

 

Πίνακας Τριών διαστάσεων με ένα μόνο στοιχείο!


Οι διαστάσεις σε έναν πίνακα μπορεί να είναι από μηδέν (κενός πίνακας) έως και δέκα. Για κάθε διάσταση από ένα μέχρι δέκα ορίζεται ο αριθμός δεικτών (όχι στοιχείων, μόνο στους μονοδιάστατους ταυτίζεται ο αριθμός αυτός με τον αριθμό στοιχείων).
Μπορούμε να φτιάξουμε έναν πίνακα τριών διαστάσεων με ένα μόνο στοιχείο!
Πίνακας Βάση 1, Μ(1,1,1)=5
Τύπωσε Μήκος(Μ()) \\ 1
Τύπωσε Μ(1,1,1) \\ 5
\\ αλλάζουμε βάση χωρίς να σβήσουμε περιεχόμενα
Πίνακας Βάση 0, Μ(1,1,1)
Τύπωσε Μήκος(Μ()) \\ 1
Τύπωσε Μ(0,0,0) \\ 5
\\ Αλλάζουμε διάσταση χωρίς να σβήσουμε περιεχόμενα
Πίνακας Μ(1)
Τύπωσε Μήκος(Μ()) \\ 1
Τύπωσε Μ(0) \\ 5

Πέμπτη, 27 Απριλίου 2017

Επικαιροποίηση του Μικρού Εγχειριδίου της Μ2000

Ενημερώθηκε το μικρό εγχειρίδιο της Μ2000. Περιλαμβάνει νέα παραδείγματα και σημειώσεις συνοπτικές για γνώστες γλωσσών.

ο σύνδεσμος βρίσκεται στην στήλη δεξιά

και εδώ

Αναθεώρηση 14 (Έκδοση 8.7)

Σε αυτήν την αναθεώρηση διόρθωσα στις ομάδες την θέαση των ιδιωτικών καταστάσεων όταν ζητάμε αλφαριθμητική τιμή από αυτές (είναι λίστες με κλειδιά)

Παρακάτω είναι ένα παράδειγμα, με δυο μέρη. Στο πρώτο φτιάχνουμε με μια κλάση ένα αντικείμενο Ομάδα που γυρνάει τιμή (έχει Αξία δηλαδή, ενώ κανονικά γυρνάει αντίγραφο ομάδας). Βλέπουμε διάφορα σχετικά, και στο δεύτερο μέρος γίνεται λόγος για τις ισχνές αναφορές (εδώ υπάρχει δυσκολία γιατί σε θέση πίνακα έχουμε βάλει πίνακα που έχει αντικείμενα).
Χρησιμοποιώ και μια Διαμέσου (Gosub) για να εμφανίζω μια λίστα μεταβλητών και μια συναρτήσεων/τμημάτων. Επίσης όλη η εξαγωγή γίνεται με αναλογική γραφή.

Γράψτε το παράδειγμα σε ένα τμήμα Α (με σ α θα ανοίξει ο διορθωτής και απλά αντιγράφεται το πρόγραμμα στο τμήμα Α - το εμφανίζει ο διορθωτής με κεφαλαία γράμματα).
Μπορεί κανείς να τρέξει μόνο το πρώτο μέρος αν βάλει τις εντολές στην Σημ 1 και 2 σε δικές τους γραμμές.
Φτιάχνω μια φόρμα 70 χαρακτήρων επί 50 γραμμές, με πράσινο περιθώριο και πράσινο φόντο στο τίτλο (τυπώνεται με την Αναφορά στο κέντρο - επιλογή 2). Η εντολή Αναφορά δίνεται μεταξύ Διπλά και Κανονικά, και έτσι εμφανίζεται με διπλάσιου ύψους-πλάτους γράμματα. Αμέσως μετά με την Οθόνη 5,2 αλλάζω το χρώμα στο ματζέντα και ορίζω ότι από την τρίτη γραμμή (το 2 είναι η τρίτη γραμμή) να έχει ολίσθηση, οπότε το χρώμα φόντου αλλάζει από την τρίτη γραμμή και κάτω (και η εντολή Οθόνη χωρίς ορίσματα θα σβήσει αυτό μόνο το τμήμα οθόνης). Μπορεί κανείς με την εντολή Πένα να αλλάξει το χρώμα γραμμάτων. Πχ Πένα 15 θα τα κάνει άσπρα. Μπορούμε με Πένα 15 { } να βάλουμε εντολές εντός ενός μπλοκ εντολών όπου το χρώμα θα είναι άσπρο και γυρνάει μετά αυτόματα στο χρώμα γραμμάτων που ήταν πριν.
Στο δικό μου διερμηνευτή χρησιμοποιώ το 14 (κίτρινο) για τα γράμματα. Τα χρώματα μπορούν να δωθούνμε και έτσι #FFFFFF για άσπρο (όπως στην Html) ή με τιμές RGB με την Χρώμα(255,255,255)




Φόρμα 70,50
Οθόνη 2
Περιθώριο {Οθόνη 2}
Τύπωσε $(4),  \\ αναλογική γραφή
Διπλά
Αναφορά 2, Μορφή$("Μ2000 έκδοση {0} αναθ. {1}", Έκδοση,Αναθεώρηση)
Κανονικά
Οθόνη 5,2
\\Καθαρό 
\\ ουσιαστικά εδώ καθαρίζει τα "σκουπίδια"
\\ θα σβήσει τυχόν δείκτες στη Κατάσταση που έμειναν από λάθος στο κώδικα
\\ δηλαδή ενδέχεται να πάρει το παλιό Άλφα, σε νέα εκκίνηση,
\\ οπότε θα βγάλει λάθος επειδή δεν δέχεται ίδια κλειδιά.
\\ Με την Δες στο τέλος καθαρίζουμε και δεν χρειάζεται η Καθαρό


\\********* Μέρος Πρώτο ***************
\\ εδώ φαίνεται πως φτιάχνουμε μια κατάσταση
\\ κοινή σε όλα τα στοιχεία του Μ$() πίνακα
\\ η οποία μόνο μια φορά φτιάχνεται, και όλα τα στοιχεία την βλέπουν
\\ αλλά ενώ μπορούμε να προσθέσουμε στοιχεία, δεν μπορούμε να αλλάξουμε
\\ τον δείκτη σε μια νέα κατάσταση
Κατάσταση Αλφα ="ένα","δύο","τρία","τέσσερα"
Κλάση Βήτα$ {
Ιδιωτικό:
      Δικόμου$
Δημόσιο:
      Ιδιότητα Κατάσταση {Αξία}
      Ιδιότητα Στοιχεία {
            Αξία {
              Ένωσε Γονικό [Κατάσταση] Στο Κ
              Αξία=Μήκος(Κ)
            }
      }
      Συνάρτηση Δείκτης$ (κ) {
            κ--
            =.[Κατάσταση]$(κ!)
      }
      Τμήμα ΆλλαξεΤιμή (κ$) {
            Αν .Δικόμου$="" Τότε ="" : Έξοδος
            Επιστροφή .[Κατάσταση], .Δικόμου$:=κ$
      }
      Αξία (κ$) {
            Αν κ$="" Τότε {
                  Αν .Δικόμου$="" Τότε ="" : Έξοδος
                  =.[Κατάσταση]$(.Δικόμου$)
            } Αλλιώς {
                  =.[Κατάσταση]$(κ$)
                  .Δικόμου$<=κ$
            }
      }

Κλάση:
      Τμήμα Βήτα {
            Διάβασε ΚΚ
                  .[Κατάσταση]<=ΚΚ
      }
}
Πίνακας Μ$(10)=Βήτα$(Αλφα)
Τύπωσε Μ$(3)("δύο")
\\ για να δώσουμε πρόσβαση σε άλλες ιδιότητες
\\ επειδή δεν μπορούν να καλεστούν με όνομα με $ στην αρχή
Ένωσε Μ$() Στο Μ()
\\ ο δείκτης μπορεί να περαστεί
Τύπωσε Μ$(3)("δύο")
\\ όχι όμως τα Στοιχεία/Δείκτης$()
Για Μ(3) {
      Για ι=1 έως .Στοιχεία {
            Τύπωσε .Δείκτης$(ι),
      }
      Τύπωσε
}
Τύπωσε Μ(3).Κατάσταση
Τύπωσε Μ(3).Στοιχεία


Για Μ(3) {
      Προσθήκη .Κατάσταση, "πέντε"
}
Τύπωσε Μ(3).Κατάσταση
Τύπωσε Μ(3).Στοιχεία
Κατάσταση ΑΑΑ=1,2,3,4,5,6
Δες οκ {
      Μ(3).Κατάσταση=ΑΑΑ
}
Αν όχι οκ Τότε Τύπωσε Λάθος$
Τύπωσε Μ(4).Στοιχεία
\\ για να πάρουμε το Μ(8) επειδή γυρνάει τιμή και όχι ομάδα
\\ πρέπει να το εξάγουμε στο σωρό
Για Μ(8) { Βάλε Αυτό}
\\ και το διαβάζουμε σε νέα μεταβλητή
Διάβασε ΜΜ$


\\ η οποία επειδή βρίσκει ομάδα θα έχει δυο παρουσίες, σαν ΜΜ$ και σαν ΜΜ
\\ ενώ στους πίνακες πρέπει να ενώσουμε το όνομα με $ με ένα όνομα χωρίς το $ στο τέλος
Τύπωσε ΜΜ$("τρια"), ΜΜ.Στοιχεία
Τύπωσε ΜΜ.Κατάσταση
Προσθήκη ΜΜ.Κατάσταση, "έξι"
Τύπωσε Μ(4).Στοιχεία \\ 6 γιατί όλα δείχνουν την ίδια Κατάσταση
Τύπωσε ΜΜ$("") \\ τρια το θυμάται


\\ Ομοίως για να αλλάξουμε το Μ(4) πρέπει να κάνουμε αυτό:
\\ Για Μ(4) { Βάλε Ομάδα(ΜΜ) : Διάβασε Αυτό}
\\ Που είναι όμοιο με αυτό:
\\ Η Στη/Στο ή Let κάνει ακριβώς μια Βάλε και μια Διάβασε
\\ εδώ χρειάζεται γιατί το Μ(4) γυρνάει τιμή, ενώ δεν δέχεται (δεν έχουμε το Θέσε { })
Για Μ(4) { Στο Αυτό = Ομάδα(ΜΜ) }
Τύπωσε Μ$(4)("") \\ δίνει τρια γιατί πήρε την τιμή της Δικόμου$


\\ Αν θέλουμε να χαλάσουμε το πρόγραμμα:
\\ στην αντιγραφή η ΜΜ$ θα πάρει νέα Κατάσταση
\\ πράγμα που δεν θα θέλαμε (αλλά μπορεί να γίνει)
\\ Απλά δεν γίνεται εύκολα, με μια απλή εκχώρηση
Στη ΜΜ$=Βήτα$(ΑΑΑ)


\\ Και εδώ την δίνουμε στην Μ(4)
Για Μ(4) { Στο Αυτό = Ομάδα(ΜΜ) }
Τύπωσε Μ$(4)("3") \\ δίνει 3
Τύπωσε Μ$(3)(""), Μ$(4)("")


\\ Μπορούμε να αλλάξουμε τιμές σε δυο θέσεις Στο πίνακα
Άλλαξε Μ(4),Μ(3)
Τύπωσε Μ$(3)(""), Μ$(4)("")


\\ Για να αλλάξουμε τιμή ώστε το 3 να έχει ό,τι και το 4
\\ δεν είναι εύκολο γιατί δεν έχουμε ορίσει το Θέσε { } ως τρόπο εκχώρησης
\\ αν δεν είχαμε ορίσει την Αξία {} θα ήταν εύκολο, γιατί θα έβλεπε απευθείας την ομάδα
\\ Υπάρχει η αντιγραφή στοιχείων πίνακα που μπορεί να το κάνει όμως
\\ χρησιμοποιείται για μαζικές μεταφορές από πίνακα σε πίνακα, ίδιο ή άλλο
Στοκ Μ(4) για 1, Μ(3)
Τύπωσε Μ$(3)(""), Μ$(4)("")


\\ Δημιουργούμε το Ν$() και μεταφέρουμε από το Μ() (που δείχνει ό,τι και το Μ$())
\\ γενικά στις μεταφορές δεν κοιτάει ο διερμηνευτής για τύπο πίνακα από το όνομα
\\ μπορούμε να μετακινούμε κατά ένα μια περιοχή στοιχείων, και η εργασία γίνεται χωρίς πρόβλημα.
\\ Οι μετακινήσεις γίνονται θεωρώντας τους πίνακες (ή έναν όπως εδώ) ως μιας διάστασης
\\ ο διερμηνευτής βρίσκει ακριβώς ποιο στοιχείο του ζητάμε, γιατί όπως και να έχει εσωτερικά
\\ όλοι οι πίνακες είναι σε μια διάσταση.
Πίνακας Ν$(2)
Στοκ Μ(0) για 2, Ν$(0)
Τύπωσε Ν$(0)("ένα"), Μ$(1)("δύο")
Ένωσε Ν$() Στο ΝΝΝΝΝ() \\ μπορούμε να δίνουμε όποιο όνομα θέλουμε, μια φορά όμως!
Τύπωσε ΝΝΝΝΝ(0).Στοιχεία \\ 6
Τύπωσε Ν$(0)("ένα")
ΝΝΝΝΝ(0).ΆλλαξεΤιμή "νέα τιμή Στο ένα"
Τύπωσε Ν$(0)("ένα")
Τύπωσε Μ$(0)("ένα") \\ άλλαξε και εδώ!
Πίνακας ΚΚ$()


\\ παίρνουμε αντίγραφο του Μ$() Στο ΚΚ$()
ΚΚ$()=Μ$()
Τύπωσε ΚΚ$(0)("ένα") \\ άλλαξε και εδώ!


\\ όμως τα Μ$(0) και ΚΚ$(0) έχουν διαφορετικές μεταβλητές
\\ απλά στην Κατάσταση έχουν το ίδιο αντικείμενο
Τύπωσε Μ$(0)("δύο"), Μ$(0)(""), ΚΚ$(0)("")


\\ ένας πίνακας μπορεί να έχει στοιχείο έναν πίνακα!
Πίνακας ΚΛΜ$(5)
ΚΛΜ$(1)=ΚΚ$()


\\ οπότε εδώ ζητάμε το 1, που είναι πίνακας, και από αυτό ζητάμε το 0 και σε αυτό δίνουμε το δείκτη!
Τύπωσε ΚΛΜ$(1)(0)("")
\\ για να δούμε τα στοιχεία πρέπει το όνομα ΚΛΜ$ να μην έχει το $


Ένωσε ΚΛΜ$() Στο ΚΛΜ()
Τύπωσε ΚΛΜ(1)(0).Στοιχεία \\ 6
Σημ 1 : Διαμέσου Δείξε_Μεταβλητές_Τμήματα
Σημ 2 : Εξοδος   \\ βάλε το Έξοδος σε δική του γραμμή, πάμε πίσω από τη λέξη και πατάμε Enter
\\ *********** Μέρος Δεύτερο ************
\\ ο λόγος που γίνεται αυτό είναι γιατί η Μ2000 έχει δείκτες ως αλφαριθμητικά
ΚΛΜ_Δείκτης$=Ισχνή$(ΚΛΜ(1))
\\ όταν έχουμε δείκτη σε πίνακα σε πίνακα έχουμε μια δυσκολία
Τύπωσε Εκφρ(ΚΛΜ_Δείκτης$+"(0)".Κατάσταση)
Τύπωσε Εκφρ(ΚΛΜ_Δείκτης$+"(0)".Στοιχεία)
\\ ο καλύτερος τρόπος είναι να περάσουμε μια οκνηρή αποτίμηση
ΚΛΜ_Δείκτης$=Οκν$(ΚΛΜ(1)(0).Κατάσταση)
Τύπωσε Συνάρτηση(ΚΛΜ_Δείκτης$)
\\ ή σε μεταβλητή
Μετρητής=0
Συνάρτηση οκν1$ {
      \\ αυτή βλέπει μεταβλητές γιατί θα δοθεί ειδικά για το σκοπό αυτό
      \\ επειδή τρέχει Στο χώρο του τμήματος
      \\ θέλουμε νέες μεταβλητές - θα είναι πρόσκαιρες, μόνο για εδώ
      Διάβασε Νέο τι, ποιός$
      =ΚΛΜ$(1)(τι)(ποιός$)
      Μετρητής++
}
Ένωσε ισχνή Οκν$(&οκν1$()) Στο ΑΑ$()
Τύπωσε ΑΑ$(0,"ένα")
Τμήμα ΣεΒάθος (&οκ$()) {
      Τύπωσε οκ$(0,"ένα")
}
\\ ουσιαστικά θα περάσουμε μέρος του τμήματος σε άλλο τμήμα
ΣεΒάθος Οκν$(&οκν1$())
\\ αυτό φαίνεται στην Μετρητής
\\ η κλήση επιφέρει αλλαγές Στο τμήμα που καλεί
\\
Τύπωσε Μετρητής \\2
Μετρ$=Ισχνή$(Μετρητής)
Μετρ$.+=10
Τύπωσε Μετρητής \\12
Τύπωσε Εκφρ(Μετρ$.) \\ 12
\\ δουλεύει και έτσι
Τύπωσε Εκφρ(Μετρ$) \\ 12
Όνομα$="Γιώργος"
Δεικτ$=Ισχνή$(Όνομα$)
\\ η πρώτη δίνει το δείκτη, η δεύτερη το περιεχόμενο
Τύπωσε Εκφρ$(Δεικτ$), Εκφρ$(Δεικτ$.)
Διαμέσου Δείξε_Μεταβλητές_Τμήματα
Έξοδος
Δείξε_Μεταβλητές_Τμήματα:
      Λίστα !
      Τμήματα ?
Επιστροφή