naked_code

Ορισμός μεταβλητών - Variable assignment

Στην R, αποδίδουμε μια τιμή σε μια μεταβλητή απ’ ευθείας, χωρίς να χρειαστεί να την ορίσουμε προηγουμένως.

my_variable = 10 ή my_variable <- 10

Χρησιμοποιούμε το = ή το <-, την διαφορά μεταξύ των δύο θα την αναλύσουμε στο κεφάλαιο σχετικά με τους τελεστές.

Είδη μεταβλητών - Types of Variables

Μπορούμε να χρησιμοποιήσουμε την συνάρτηση class() ώστε να εξακριβώσουμε το είδος κάποιας μεταβλητής

bool_var = FALSE
print(bool_var)

## [1] FALSE

print(class(bool_var))

## [1] "logical"

x = 12L
print(x)

## [1] 12

print(class(x))

## [1] "integer"

x = 12.5
print(x)

## [1] 12.5

print(class(x))

## [1] "numeric"

z = 1 + 2i
print(z)

## [1] 1+2i

print(class(z))

## [1] "complex"

one_character = "a"
str = 'abcdefg'
print(one_character)

## [1] "a"

print(class(one_character))

## [1] "character"

print(str)

## [1] "abcdefg"

print(class(str))

## [1] "character"

as.logical(c(1,0))

## [1]  TRUE FALSE

as.numeric(c(TRUE, FALSE))

## [1] 1 0

as.character(c(1,2,3))

## [1] "1" "2" "3"

Διάνυσμα - Vector

Είναι η πιο συνηθισμένη δομή δεδομένων στην R. Δημιουργούνται με την συνάρτηση vector() ή (συχνότερα) με την συνάρτηση c().

Υπάρχουν δύο είδη vectors. Τα atomic vectors, περιέχουν κάποιο απ’ τα είδη τιμών, αλλά μόνο το ίδιο. Τα recursive vectors μπορούν να περιέχουν διαφορετικά είδη τιμών και δεδομένων.

vector1 = c() #same as "vector1 = vector()"
vector2 = c("numeric", length = 10) #vectors can have pre-defined length and datatype
vector3 = c(2,1,4,3,2)
vector4 = c("ab","cd","hi")

print(vector3)

## [1] 2 1 4 3 2

Στην R, μπορούμε να κάνουμε με σχετική ευκολία πράξεις, χρησιμοποιώντας τους κανονικούς τελεστές.

print(vector3 ** 2) #every element is squared

## [1]  4  1 16  9  4

print(vector3 + 0.2)

## [1] 2.2 1.2 4.2 3.2 2.2

Ορισμένες χρήσιμες συναρτήσεις:

print(max(vector3)) #maximum

## [1] 4

print(min(vector3)) #minimum

## [1] 1

print(mean(vector3)) #arithmetic average

## [1] 2.4

print(class(vector3))

## [1] "numeric"

print(length(vector3)) #length/size of the vector

## [1] 5

print(str(vector3)) #internal stracture of vector

##  num [1:5] 2 1 4 3 2
## NULL

print(sort(vector3)) #returns the vector sorted

## [1] 1 2 2 3 4

print(rev(vector3)) #returns the vector inversed

## [1] 2 3 4 1 2

print(unique(vector3)) #returns the unique values of the vector

## [1] 2 1 4 3

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

Επιλογή με βάση την θέση. Αξίζει να σημειωθεί ότι στην R, οι δείκτες θέσης των διανυσμάτων ξεκινούν από το 1. Το πρώτο στοιχείο του διανύσματος είναι το vector[1], το δεύτερο είναι το vector[2], κοκ. Στις περισσότερες γλώσσες προγραμματισμού (Python, το πρώτο στοιχείο έχει δείκτη το 0. Αυτό είναι φυσικά θέμα σύμβασης. Για περαιτέρω μελέτη.

vector3[3] #the third element

## [1] 4

vector3[-3] #everything BUT the third element

## [1] 2 1 3 2

vector3[1:3] #elements one to three

## [1] 2 1 4

vector3[-(1:3)] #all elements EXCEPT those one to three

## [1] 3 2

vector3[c(1,3)] #elements one and three

## [1] 2 4

Επιλογή με βάση την τιμή

vector3[vector3 == 2] #all elements equal to two

## [1] 2 2

vector3[vector3 < 3] #all elements less than three

## [1] 2 1 2

vector3[vector3 %in% c(1,2,5)] #elements in the set 1,2,5

## [1] 2 1 2

vector3["a"] #elements with name "ab"

## [1] NA

Εκτός από την επιλογή στοιχείων, μπορούμε και να αλλάξουμε τα στοιχεία ενός διανύσματος στην R.

Για παράδειγμα, μπορούμε να προσθέσουμε στοιχεία στο διάνυσμα. Η συνάρτηση append() επιστρέφει ένα νέο vector, το οποίο

vector3 <- append(vector3, 10, 5) #vector3 is the vector to append, 10 is the appended value, 5 (optional) is the index of the appended item

Πίνακας - Matrix

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

Οι πίνακες χρησιμοποιούν (και περιέχουν) vectors για την αποθήκευση των δεδομένων.

Ορισμός πίνακα:

matrix(vector, nrow, ncol, byrow = FALSE)

• vector: το διάνυσμα δεδομένων με το οποίο θα γεμίσουμε τον πίνακα

• nrow: αριθμός των σειρών του πίνακα

• ncol: αριθμός των στηλών του πίνακα

• byrow: μπορούμε να μην το ορίσουμε, από μόνο του είναι ορισμένο σε FALSE. Αν είναι ορισμένο TRUE, τότε ο πίνακας δεν γεμίζει ανά στήλη, αλλά ανά σειρά.

#creating a 3x2 matrix and filling it with 1,2,3,4,5,6
matrix1 = matrix(c(1,2,3,4,5,6), nrow = 3, ncol = 2)
print(matrix1)

##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6

#creating a 2x3 matrix and filling it with 1,2,3,4,5,6 BY ROW
matrix2 = matrix(c(1,2,3,4,5,6), nrow = 2, ncol = 3, byrow = TRUE)
print(matrix2)

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

Η πρόσβαση σε στοιχεία του πίνακα γίνεται ως εξής: matrix[x, y] , όπου x είναι ο αριθμός της σειράς και y ο αριθμός της στήλης στην οποία βρίσκεται το στοιχείο που θέλουμε να δούμε/επεξεργαστούμε/σβήσουμε.

print(matrix1[3,2])

## [1] 6

print(matrix2[1,3])

## [1] 3

Αν αφήσουμε κενή μία απ’ τις δύο τιμές, τότε έχουμε πρόσβαση σε όλη την σειρά ή στήλη.

print(matrix1[, 2])

## [1] 4 5 6

print(matrix2[1, ])

## [1] 1 2 3

Μπορούμε να υπολογίσουμε τον ανάστροφο (transposed) πίνακα με την t()

t(matrix1)

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

Πολλαπλασιάζουμε πίνακες με τον τελεστή %*% , όπως είδαμε και παραπάνω

matrix1 %*% matrix2

##      [,1] [,2] [,3]
## [1,]   17   22   27
## [2,]   22   29   36
## [3,]   27   36   45

Εξαιρετικά χρήσιμη είναι η συνάρτηση solve(m, n) για την επίλυση της εξίσωσης m * x = n . Συνήθως χρησιμοποιείται για την εύρεση του αντιστρόφου πίνακα, όταν το n μείνει κενό.

square_matrix = matrix(c(-1, 1, 3/2, -1), nrow = 2, ncol = 2)
solve(square_matrix)

##      [,1] [,2]
## [1,]    2    3
## [2,]    2    2

Λίστα - List

Παρόμοια με τα vectors. Η R έχει πολλά διαφορετικά εργαλεία που κάνουν (ή μπορούν να κάνουν) ακριβώς το ίδιο πράγμα, ώστε να μην δυσαρεστήσει ή ξεβολέψει όποιον έχει συνηθίσει έναν όρο ή έναν τρόπο λειτουργίας της γλώσσας προγραμματισμού.

Κάποιος υπερασπιστής της R θα έλεγε ότι οι λίστες είναι recursive vectors (αναδρομικά διανύσματα), επειδή μπορούν να αποθηκεύουν υπο-λίστες. Ωστόσο, το ίδιο μπορούν να κάνουν ΚΑΙ τα vectors (ή τουλάχιστον, ίδια είναι η χρήση ακόμη κι αν η κατηγοριοποίηση είναι διαφορετική για την γλώσσα προγραμματισμού).

vector1 = c(c(1,2,3), 2, c(c(c(c(c(1))))), c("r is so fun!", "yes"))
print(vector1)

## [1] "1"            "2"            "3"            "2"            "1"           
## [6] "r is so fun!" "yes"

Πολύ συνοπτικά,

#creating a list
#x,y,z are the names of the elements (same can be done with vectors)
l <- list(x = 1, y = 2, z = 3)
print(l[[2]])

## [1] 2

print(l$z)

## [1] 3

print(l['y'])

## $y
## [1] 2

Για περαιτερω μελετη.

Διάταξη - Array

Η λογική των Array είναι ακριβώς ίδια με αυτή των πινάκων, ωστόσο μπορούμε να έχουμε παραπάνω από δύο διαστάσεις.

array3d <- array(c(1:24), dim = c(4, 3, 2))
print(array3d)

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   13   17   21
## [2,]   14   18   22
## [3,]   15   19   23
## [4,]   16   20   24

Για περαιτερω μελετη.

Πλαίσιο δεδομένων - Data frame

Το Data Frame χρησιμοποιείται όπως ο πίνακας. Είναι μια 2x2 διάταξη δεδομένων που μπορεί να περιέχει διανύσματα ως στήλες και σειρές, τα οποία διανύσματα μπορούν να έχουν διαφορετικούς τύπους δεδομένων.

my_dataframe <- data.frame(
    first_col  = c(val1, val2, ...),
    second_col = c(val1, val2, ...),
    ... )

Για παράδειγμα:

eklogikos_katalogos <- data.frame (
  Name = c("Γεώργιος Μπίθας", "Αλίκη Περπέρογλου", "Αναστάσιος Μήτσος"),
  Age = c(54, 21, 15),
  Able_to_vote = c(TRUE, TRUE, FALSE)
)

print(eklogikos_katalogos)

##                Name Age Able_to_vote
## 1   Γεώργιος Μπίθας  54         TRUE
## 2 Αλίκη Περπέρογλου  21         TRUE
## 3 Αναστάσιος Μήτσος  15        FALSE

Μπορούμε να διαβάσουμε συγκεκριμένες στήλες από το data frame.

Για παράδειγμα, αν μας ενδιαφέρουν μόνο τα ονόματα του εκλογικού καταλόγου:

print(eklogikos_katalogos[1]) #an gnwrizoume oti to onoma einai h prwth sthlh

##                Name
## 1   Γεώργιος Μπίθας
## 2 Αλίκη Περπέρογλου
## 3 Αναστάσιος Μήτσος

print(eklogikos_katalogos[["Name"]]) #an den gnwrizoume poia sthlh periexei to onoma

## [1] "Γεώργιος Μπίθας"   "Αλίκη Περπέρογλου" "Αναστάσιος Μήτσος"

print(eklogikos_katalogos$Name) #diaforetikos tropos grafhs tou prohgoumenou

## [1] "Γεώργιος Μπίθας"   "Αλίκη Περπέρογλου" "Αναστάσιος Μήτσος"

Καλό είναι να γνωρίζουμε, ότι απ’ την παραπάνω υλοποίηση το eklogikos_katalogos[1] επιστρέφει list ενώ τα άλλα δύο επιστρέφουν character.

Μπορούμε επίσης να προσθέσουμε σειρές με την rbind()

eklogikos_katalogos <- rbind(eklogikos_katalogos,
                             c("Ιωάννης Χαραλάμπους", 25, TRUE))
print(eklogikos_katalogos)

##                  Name Age Able_to_vote
## 1     Γεώργιος Μπίθας  54         TRUE
## 2   Αλίκη Περπέρογλου  21         TRUE
## 3   Αναστάσιος Μήτσος  15        FALSE
## 4 Ιωάννης Χαραλάμπους  25         TRUE

Αντίστοιχα, προσθέτουμε στήλες με την cbind()

eklogikos_katalogos <- cbind(eklogikos_katalogos, District = 
                                 c("Attiki", "Ioannina", "Thessaloniki", "Chania"))
print(eklogikos_katalogos)

##                  Name Age Able_to_vote     District
## 1     Γεώργιος Μπίθας  54         TRUE       Attiki
## 2   Αλίκη Περπέρογλου  21         TRUE     Ioannina
## 3   Αναστάσιος Μήτσος  15        FALSE Thessaloniki
## 4 Ιωάννης Χαραλάμπους  25         TRUE       Chania

Μια χρήσιμη συνάρτηση για τα Data Frames είναι η summary() , η οποία επιστρέφει διάφορα σημαντικά δεδομένα για το πλαίσιο δεδομένων.

print(summary(eklogikos_katalogos))

##      Name               Age            Able_to_vote         District        
##  Length:4           Length:4           Length:4           Length:4          
##  Class :character   Class :character   Class :character   Class :character  
##  Mode  :character   Mode  :character   Mode  :character   Mode  :character

Για περαιτερω μελετη.

Πρόταση υπό όρους - If statement

Για αρχή, ας δούμε το if statement. Στην R, ακόμη κι οι έλεγχοι ροής είναι τυπικά συναρτήσεις. Ωστόσο λειτουργούν όπως σε κάθε άλλη γλώσσα.

x <- 1

if (x == 1) {
    print("x is equal to 1")
}

## [1] "x is equal to 1"

if (x == 2) {
    print("x is equal to 2")
}

Υπάρχει επίσης το else if που χρησιμοποιείται μετά το if ώστε να εξετάσουμε άλλους όρους, εφόσον το πρώτο if δεν ισχύει. Το else χωρίς να ακολουθεί if εκτελείται σε περίπτωση που δεν ισχύει κανένα από τα προηγούμενα statements. Μπορούμε να χρησιμοποιούμε περισσότερα από ένα else if ανά έλεγχο.

x <- 1
if (x < 0) {
    print ("x is negative")
} else if (x > 0) {
    print ("x is positive")
} else {
    print ("x is equal to zero")
}

## [1] "x is positive"

fruit <- "banana"

if (fruit == "apple") {
    print ("the fruit is an apple")
} else if (fruit == "peach") {
    print ("the fruit is a peach")
} else if (fruit == "pear") {
    print ("the fruit is a pear")
} else if (fruit == "orange") {
    print ("the fruit is an orange")
} else {
    print ("unknown fruit")
}

## [1] "unknown fruit"

Για περαιτερω μελετη.

Δομές επανάληψης (λούπες) - Loops

Υπάρχουν δύο βασικά είδη λούπας. Κάθε διεργασία που μπορεί να πραγματοποιηθεί με το ένα είδος λούπας, μπορεί να πραγματοποιηθεί και με το άλλο. Συνεπώς η επιλογή μεταξύ των δύο είναι θέμα ευκολίας, αισθητικής και ευκολίας.

i <- 0

while (i < 5) {
    i <- i + 1
    print (i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

for (x in 1:5) {
    print (x)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

dice <- c(1, 2, 3, 4, 5, 6)

for (number in dice) {
  print(number)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6

animals <- c('cat', 'dog', 'komodo dragon')

for (animal in animals) {
    print (animal)
}

## [1] "cat"
## [1] "dog"
## [1] "komodo dragon"

fruits <- list("apple", "banana", "cherry")

for (x in fruits) {
  if (x == "cherry") {
    break
  }
  print(x)
}

## [1] "apple"
## [1] "banana"

fruits <- list("apple", "banana", "cherry")

for (x in fruits) {
  if (x == "banana") {
    next
  }
  print(x)
}

## [1] "apple"
## [1] "cherry"

Ορισμός και βασικές λειτουργίες

Ο ευνόητος τρόπος να προσεγγίσουμε τις συναρτήσεις στον προγραμματισμό, είναι ως ένα μπλοκ εντολών το οποίο

1. μπορεί να λάβει παραμέτρους
2. εκτελείται όταν καλείται
3. μπορεί να επιστρέφει κάποια τιμή

Για περαιτερω μελετη.

Υπάρχουν ορισμένες βασικές συναρτήσεις που συμπεριλαμβάνονται στην γλώσσα. Κάποιες από αυτές τις έχουμε συναντήσει ήδη (το print , το length κ.α.)

Είναι πολύ συχνό το να χρειαζόμαστε κάποια συνάρτηση η οποία δεν υπάρχει ούτε στην γλώσσα προραμματισμού (built-in function), ούτε σε κάποια βιβλιοθήκη που μπορούμε να κατεβάσουμε από το ίντερνετ (library).

Τότε πρέπει να γράψουμε οι ίδιοι την συνάρτηση, δηλαδή το μπλοκ εντολών που μπορούμε να χρησιμοποιούμε πολλές φορές.

Δημιουργούμε μια συνάρτηση ως εξής:

my_function <- function() {
    print("My first function!")
}

Καλούμε την συνάρτηση με τον γνωστό τρόπο:

my_function()

## [1] "My first function!"

Αρκετές φορές, χρειάζεται να περάσουμε παραμέτρους και να επιστρέψουμε τιμές χρησιμοποιώντας μία συνάρτηση.

Ας δούμε, για παράδειγμα, πώς θα υλοποιούσαμε μία απλή συνάρτηση που ελέγχει έναν αριθμό. Αν αυτός είναι άρτιος/ζυγός, επιστρέφει TRUE . Αν είναι περιττός/μονός, επιστρέφει FALSE .

#etsi leme sto programma oti h synarthsh perimenei mia parametro
is_even <- function(number) {
    #an o arithmos diaireitai teleia me to 2
    if (number %% 2 == 0) {
        #tote epistrefoume TRUE
        return (TRUE)
    #an oxi
    } else {
        #tote epistrefoume FALSE
        return (FALSE)
    }
}

print(is_even(5))

## [1] FALSE

print(is_even(10))

## [1] TRUE

Κάποιες φορές, χρειάζεται να περάσουμε παραπάνω από μία παράμετρο. Διαχωρίζουμε τις παραμέτρους με , , τόσο στον ορισμό της συνάρτησης, όσο και στην κλήση της.

Ας γράψουμε μία συνάρτηση που ελέγχει αν το πρώτο και το δεύτερο όνομα ενός ανθρώπου ξεκινούν από το ίδιο γράμμα.

same_first_letter <- function(firstname, lastname) {
    if (substr(firstname, 1, 1) == substr(lastname, 1, 1)) {
        return (TRUE)
    } else {
        return (FALSE)
    }
}

print(same_first_letter("Mixalis", "Mimikos"))

## [1] TRUE

print(same_first_letter("Charalampos", "Lamprou"))

## [1] FALSE

Αντίστοιχα φυσικά μπορούμε να υλοποιήσουμε συναρτήσεις με 3, 4, 5 κ.ο.κ. παραμέτρους.

Συχνά είναι χρήσιμο για την ευκολία της κλήσης της συνάρτησης είναι να ορίζουμε κάποιες προεπιλεγμένες τιμές των παραμέτρων (default values). Δηλαδή,

#edw orizoume tis default times
same_first_letter <- function(firstname = "John", lastname = "Doe") {
    if (substr(firstname, 1, 1) == substr(lastname, 1, 1)) {
        return (TRUE)
    } else {
        return (FALSE)
    }
}

print(same_first_letter())

## [1] FALSE

Έτσι η same_first_letter εκτελείται με τις προεπιλεγμένες τιμές John Doe . Επιστρέφει FALSE εφόσον φυσικά δεν αρχίζουν απ’ το ίδιο γράμμα.

Αναδρομή - Recursion

Η αναδρομή είναι ένας εξαιρετικά χρήσιμος, αλλά συχνά δυσνόητος τρόπος να χρησιμοποιήσουμε μια συνάρτηση. Δημιουργείται όταν μια συνάρτηση καλεί τον εαυτό της ώστε να επιτύχει κάποιον υπολογισμό. Μπορούμε να την αντιμετωπίζουμε σαν μια μορφή αναδρομικής επανάληψης.

Για περαιτερω μελετη.

Για να είναι επιτυχημένος ένας αναδρομικός αλγόριθμος, υπάρχουν 3 κανόνες που δεχόμαστε σαν αξιώματα.

1. πρέπει να υπάρχει ένας βασικός έλεγχος - base case
2. ο αλγόριθμος πρέπει να κινείται προς τον βασικό έλεγχο
3. ο αλγόριθμος πρέπει να καλεί τον εαυτό του.

Επειδή η αναδρομή (recursion) είναι - συνήθως - πιο δυσνόητη από τις λούπες που παρουσιάσαμε πριν (iteration), είναι σημαντικό να γνωρίζουμε πότε είναι χρήσιμη.

Όλα τα προβλήματα που έχουν θεωρητική λύση με τον έναν τρόπο, έχουν και με τον άλλον. Υπάρχουν όμως προβλήματα που λύνονται πρακτικά μόνο με τον έναν. Ακόμη κι αν υπάρχει κάποια θεωρητική λύση με τον άλλον - είναι πολύ περίπλοκη και χρονοβόρα, είτε για τον άνθρωπο, είτε για τον υπολογιστή, είτε και για τους δύο. Πώς θα ξεχωρίσουμε ποια μέθοδος είναι η βέλτιστη όταν υπάρχει επικάλυψη;

Η αναδρομή χρησιμοποιείται στην βάση του διαίρει και βασίλευε. Είναι άξια χρήσης όταν το μεγάλο πρόβλημα ανάγεται σε μικρότερα, επαναλαμβανόμενα προβλήματα. Λύνοντας τα μικρά προβλήματα, βρίσκουμε την λύση στο μεγάλο.

’Ενα χαρακτηριστικό παράδειγμα είναι ο υπολογισμός αριθμών που εμπίπτουν στην ακολουθία Φιμπονάτσι.

Οι αριθμοί Φιμπονάτσι είναι η ακολουθία αυτής της μορφής:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ... , ...

Παρατηρούμε ότι κάθε αριθμός είναι το άθροισμα των δύο προηγούμενων.

Πληροφοριακά, το όριο του πηλίκου ενός αριθμού Φιμπονάτσι διά τον προηγούμενο στο +∞ ισούται με φ, την λεγόμενη χρυσή τομή.

\(lim_{n⤍+∞}{F_{n+1}\over{F_n}} = φ ≅ 1.61803\)

Έστω ότι θέλουμε να γράψουμε μία συνάρτηση που υπολογίζει τον ν-οστό αριθμό της ακολουθίας. Προφανώς η συνάρτηση χρειάζεται ως παράμετρο τον αριθμό n .

fib <- function(n) {}

Χρειαζόμαστε επίσης ένα base-case, ένα σημείο στο οποίο ο αλγόριθμος σταματάει να καλεί τον εαυτό του.

Αν παρατηρήσουμε τους πρώτους αριθμούς της ακολουθίας σε σχέση με την θέση (μετρώντας απ’ το 0), βλέπουμε το εξής:

ΤΙΜΕΣ: 0, 1, 1

ΘΕΣΗ: 0 1 2

Όταν η θέση είναι 1 ή 0 , δηλαδή όταν n == 0 ή n == 1 , τότε ο αριθμός της τιμής που αντιστοιχεί σε αυτές τις θέσεις n , είναι ο ίδιος με την θέση.

Άρα το base-case μας μπορεί να είναι

if (n <= 1) { return n }

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

Θα σχεδιάσουμε το πρόγραμμα ώστε όταν του ζητάμε έναν αριθμό, της ακολουθίας, θα ξεκινάει από αυτόν και θα προσθέτει τους δύο προηγούμενους μέχρι να φτάσει στο base-case.

Δηλαδή,

Το fib(5) (για παράδειγμα) προσπαθεί να υπολογίσει τον εαυτό του, κι έτσι καλεί το άθροισμα των δύο προηγούμενων, fib(4) και fib(3) (έτσι ορίσαμε τους αριθμούς Φιμπονάτσι).

Ενδεικτικά ας ακολουθήσουμε την πορεία του γράφου προς τα δεξιά. Για να υπολογιστεί το fib(3) , η συνάρτηση καλεί και αθροίζει τους δύο προηγούμενους, fib(2) και fib(1) .

Ο fib(2) αντίστοιχα καλεί αθροίζοντας τους fib(1) και fib(0) .

Κι όπως βλέπουμε, φτάσαμε επιτέλους στο base-case. Τα fib(1) και fib(0) είναι γνωστά, οπότε το πρόγραμμα σταματάει τους υπολογισμούς, αθροίζει πλέον όλους τους γνωστούς αριθμούς μέχρι να φτάσει δενδρωδώς στο fib(5) .

Το τελικό πρόγραμμα θα ήταν το εξής:

fib <- function(n) {
    if (n <= 1) return (n)
    else return (fib(n-1) + fib(n-2))
}

print(fib(4))

## [1] 3

print(fib(6))

## [1] 8

print(fib(10))

## [1] 55

Για περαιτερω μελετη.

Παρότι αυτός ο τρόπος υλοποίησης είναι σχετικά εύκολα κατανοητός, λιτός και απέριττος, δεν είναι σε καμία περίπτωση ο πιο γρήγορος τρόπος σε χρόνο υπολογισμού. Μπορείτε να σκεφτείτε κάποιο βασικό χρονικό μειονέκτημα αυτού του αλγορίθμου;

Για περαιτερω μελετη.