Riassunto Lezioni Ruby (colori) PDF

Preview

Summary

riassunto di tutto il corso di informatica...

Description

#!/usr/bin/env ruby =begin PRIMO SCRIPT!😊 😊 =end # Salviamo dentro una variabile un intero # e lo stampiamo a schermo variabile = 1000 puts(variabile) # puts() e' una funzione =begin Tutto quello all'interno non viene eseguito DEVE ESSERE ALL'INIZIO DELLA RIGA!!! variabile = 1000.0 puts(variabile) =end variabile = 5/8 puts(variabile) variabile = 5.0/8.0 puts(variabile) variabile = 5/8.0 puts(variabile) variabile = 5.0/8 puts(variabile) variabile = "Hello World!" puts(variabile)

1

#!/usr/bin/env ruby =begin Operazioni_Matematiche =end a = 5.42 b = 4.2 somma = a + b puts(somma) differenza = a – b puts(differenza) prod = a * b puts(prod) div = a / b puts(div) pow= a ** b puts(pow) # Elevamento a potenza # Importante è l'indentazione di un testo! # Lasciare spazi fra le operazioni per migliorare la lettura! # Valgono solo le parentesi () per i calcoli! sqrt = a ** (0.5) puts(sqrt) sqrt = Math::sqrt(a) puts(sqrt) sqrt = a ** (1.0/3.0) puts(sqrt) sin = Math::sin(a) puts(sin) cos = Math::cos(a) puts(cos)

2

#!/usr/bin/env ruby

log = false puts("log e' false") if log

log = true

puts("log e' true") if log

log = false puts("log e' false") if log if log==true puts("log e' false") end

log = true puts("log e' true") if log if log == true puts("log e' true") end

3

#!/usr/bin/env ruby =begin Fattoriale di n =end n=10 y=1 for i in 2..n y=y*i end puts("#{n}! = #{y}")

#!/usr/bin/env ruby =begin Funzione fattoriale di n =end def fatt(n) z=1 for j in 2..n z=z*j # puts("z = #{z}") per controllare l'iterazione del ciclo su z end return z end n=10 y=fatt(n) puts("#{n}! = #{y}")

4

#!/usr/bin/env ruby =begin Funzione ricorsiva fattoriale di n =end def fatt(n) return 1 if n==1 return n * fatt(n-1) end n=10 y=fatt(n) puts("#{n}! = #{y}")

#!/usr/bin/env ruby =begin Coefficiente binomiale e fattoriale di n e k =end def fatt(n) z=1 for j in 2..n z=z*j end return z end def coeff_bin(n, k) z=0 a=fatt(n) b=fatt(k) c=n-k d=fatt(c) z=a/(b*d) return z end

5

n=10 k=6 y=fatt(n) cofbin=coeff_bin(n, k) puts("#{n}! = #{y}") puts("coeff_bin di #{n} e #{k} = #{cofbin}")

#!/usr/bin/env ruby =begin Calcolo delle radici di un polinomio di secondo ordine a * (x ** 2) + b * x + c = 0 =end a = 1.0 b = 2.0 c = 1.0 delta = b ** 2 - (4 * a * c) # Inizializzazione variabili fuori da qualsiasi ciclo o contesto x1r = 0.0 x2r = 0.0 x1i= 0.0 x2i= 0.0 # Se delta >= 0 radici reali, in alternativa delta < 0 radici complesse # == serve per comparare se sono uguali due variabili # v1 > v2 serve per comparare # in modo analogo # v1 >= v2 # v1 < v2 # v1 = 0) # codice per condizione vera sqrt_delta = delta ** (0.5) x1r = (-b + sqrt_delta) / (2 * a) x2r = (-b - sqrt_delta) / (2 * a) else # codice per condizione falsa sqrt_delta = (-delta) ** (0.5) x1r = -b / (2 * a) x2r = -b / (2 * a) x1i = sqrt_delta / (2 * a) x2i = -sqrt_delta / (2 * a) end # Interpolazione della stringa x1_str = "x1 = #{x1r} + I #{x1i}" x2_str = "x2 = #{x2r} + I #{x2i}" puts(x1_str) puts(x2_str)

7

#!/usr/bin/env ruby =begin MENU DEL GIORNO # Lezione 17/03/2017 *ricordiamo FOR e WHILE *Gli ARRAY *concetto *inserimento e estrazioni valori *loop su array *Le HASH *il concetto chiave valore *ottenere le chiavi *accedere ai valori *iterare sulle chiavi per i valori *Esercitazione in aula =end =begin #assegnazione variabile a = 10 ---------------------------------------while condizione ..... #i+=1 che significa i=i+1 end ---------------------------------------for (indice) in a..b ..indice.. end ---------------------------------------i+=1 i-=1 a*=2 che significa a=a*2 ---------------------------------------- Operatore ternario (condizione ? , V : F) ---------------------------------------Varie tipologie di variabile Fixnum Float String Se devo salvare più dati -> ARRAY ----------------------------------------

8

ARRAY Scatolone con scomparti ordinati da 0 a n. In ogni scomparto posso trovare : 10, "Ciao", 0.5 etc... tutto il resto ---------------------------------------Come costruisco un ARRAY? ary = [10, "ciao", 0.5] ---------------------------------------TERMINALE irb(main):001:0> a = 10 => 10 irb(main):002:0> ary = [a, "ciao", 0.5] => [10, "ciao", 0.5] ---------------------------------------ary.size() oppure ary.length() #con o senza () parentesi ary [0] --> 10 irb(main):010:0> ary [0..1] #con dei range => [10, "ciao"] irb(main):013:0* ary[0..1][1] => "ciao" irb(main):014:0> bry=ary[0..1] => [10, "ciao"] irb(main):015:0> bry[1] => "ciao" ---------------------------------------INDICI Fixnum, Range irb(main):016:0> ary => [10, "ciao", 0.5] irb(main):017:0> ary.size => 3 irb(main):018:0> ary[ary.size - 1] #l'array parte da zero => 0.5 irb(main):019:0> ary[2] => 0.5 irb(main):020:0> ary[-1] => 0.5 irb(main):021:0> ary [10] => nil irb(main):022:0> ary[ary.size] #essendo ZERO BASED nell'ultima posizione non c'è NULLA! => nil #NULLA!!! ----------------------------------------

9

irb(main):002:0> ary=[10,"ciao",0.5] => [10, "ciao", 0.5] irb(main):003:0> ary.size => 3 irb(main):004:0> ary[10]="Sono il 10" => "Sono il 10" irb(main):005:0> ary.size => 11 irb(main):006:0> ary => [10, "ciao", 0.5, nil, nil, nil, nil, nil, nil, nil, "Sono il 10"] ---------------------------------------irb(main):007:0> ary[2]=1.5 => 1.5 irb(main):008:0> ary => [10, "ciao", 1.5, nil, nil, nil, nil, nil, nil, nil, "Sono il 10"] ---------------------------------------irb(main):002:0> ary=[] #Array vuoto => [] irb(main):003:0> ary.size => 0 irb(main):004:0> ary[ary.size] = "Sono il primo!!" => "Sono il primo!!" irb(main):005:0> ary.size => 1 irb(main):006:0> ary => ["Sono il primo!!"] irb(main):007:0> ary ["Sono il primo!!", "Sono il secondo!!"] ---------------------------------------irb(main):001:0> ary=[] => [] irb(main):002:0> for i in 1..10 irb(main):003:1> ary end => 1..10 irb(main):005:0> ary => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ---------------------------------------irb(main):006:0> for j in 0...ary.size irb(main):007:1> ary[j] *= 2 irb(main):008:1> end => 0...10 irb(main):009:0> ary => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

10

MATRICI irb(main):011:0> mtr = [ [1, 2], [3, 4] ] => [[1, 2], [3, 4]] irb(main):012:0> mtr => [[1, 2], [3, 4]] irb(main):013:0> mtr[0][1] => 2 Rappresentazione matrice 0 1 0|1 2| 1|3 4| ovvero = [ [1, 2], [3, 4] ] Nota bene: mtr[RIGA][COLONNA] ---------------------------------------Per duplicare un array: #in questo modo non ho il problema del cambio dei valori delle variabili nella RAM a causa dei puntatori da vettore a RAM irb(main):014:0> mtr => [[1, 2], [3, 4]] irb(main):015:0> mtr[0][1] = 10 => 10 irb(main):016:0> mtr => [[1, 10], [3, 4]] irb(main):017:0> mtr[0][1] = 2 => 2 irb(main):018:0> mtr => [[1, 2], [3, 4]] irb(main):019:0> ntr = mtr => [[1, 2], [3, 4]] irb(main):020:0> ntr[0][1] = 10 => 10 irb(main):021:0> ntr => [[1, 10], [3, 4]] irb(main):022:0> mtr => [[1, 10], [3, 4]] irb(main):023:0> ntr[1] = "pippo" => "pippo" irb(main):024:0> ntr => [[1, 10], "pippo"] irb(main):025:0> mtr => [[1, 10], "pippo"] irb(main):026:0> ltr = mtr.clone #in questo modo non modifico mtr[][] => [[1, 10], "pippo"] irb(main):027:0> ltr[0] = "Sono clonato" => "Sono clonato"

11

irb(main):028:0> mtr => [[1, 10], "pippo"] irb(main):029:0> ltr => ["Sono clonato", "pippo"] ---------------------------------------irb(main):003:0> mtr = [[1, 2], [3, 4]] => [[1, 2], [3, 4]] irb(main):004:0> mtr[1]="pippo" => "pippo" irb(main):005:0> mtr => [[1, 2], "pippo"] irb(main):006:0> mtr[0][1]=10 => 10 irb(main):007:0> mtr => [[1, 10], "pippo"] irb(main):008:0> mtr.delete(1) #non si usa! => nil irb(main):009:0> mtr => [[1, 10], "pippo"] irb(main):010:0> mtr - ["pippo"] => [[1, 10]] irb(main):011:0> mtr => [[1, 10], "pippo"] irb(main):012:0> mtr + ["pippo"] => [[1, 10], "pippo", "pippo"] irb(main):013:0> mtr => [[1, 10], "pippo"] irb(main):014:0> a=10 => 10 irb(main):015:0> a + 1 => 11 irb(main):016:0> a => 10 irb(main):017:0> ---------------------------------------Eliminare tutti gli elementi uguali a 1 a = [1,2,3,1,5] for i in 0...5 a = a - [1] #elimino tutti gli elementi uguali a 1 e accorcio il #vettore! end ----------------------------------------

12

irb(main):017:0> ary = [1,2,3,4,5] => [1, 2, 3, 4, 5] irb(main):018:0> ary.first #vedere il primo elemento => 1 ---------------------------------------#C'è differenza tra visualizzazione o assegnazione!!! irb(main):019:0> a=[1,2,3,4,5] => [1, 2, 3, 4, 5] irb(main):020:0> a - [1] => [2, 3, 4, 5] irb(main):021:0> a => [1, 2, 3, 4, 5] irb(main):022:0> a -= [1] => [2, 3, 4, 5] irb(main):023:0> a => [2, 3, 4, 5] ---------------------------------------for i in 0...5 a[i] = nil if a[i] == 1 a[i] += 1 if a[i] ************************* end ---------------------------------------Le HASH -> array disordinati che necessitano di una key [chiave] Gli indici non sono numeri naturali ma sono delle KEY! irb(main):001:0> hsh = {} => {} irb(main):002:0> hsh["pippo"] = "valore puntato da pippo" => "valore puntato da pippo" irb(main):003:0> hsh["pippo"] => "valore puntato da pippo" irb(main):004:0> hsh[[1,2]] = 1000 => 1000 irb(main):005:0> hsh[1] = ["valore", "puntato", "da", "1"] => ["valore", "puntato", "da", "1"] irb(main):006:0> hsh => {"pippo"=>"valore puntato da pippo", [1, 2]=>1000, 1=>["valore", "puntato", "da", "1"]} irb(main):007:0> bsh = {"chiave" => [1,2,3,4,5]} => {"chiave"=>[1, 2, 3, 4, 5]} irb(main):008:0> bsh = {[1,2] => [1,2,3,4,5]} => {[1, 2]=>[1, 2, 3, 4, 5]} irb(main):009:0> config = {"toll" => 1e-9, "maxiter" => 1000} => {"toll"=>1.0e-09, "maxiter"=>1000} irb(main):010:0> config["toll"]

13

=> 1.0e-09 irb(main):012:0> config["toller"] => nil ---------------------------------------=end def algoritmo(x, y, config) # l'algoritmo deve conoscere # * il massimo numero diiterazioni consentite # * la tolleranza richiesta dall'algoritmo config_interna = { "tol" => 1e-9, "maxiter" => 1000 # "giovanni" => 1 # "nuovaChiave" => false } config_interna["tol"] = config["tol"] if config["tol"] config_interna["maxiter"] = config["maxiter"] if config["maxiter"] =begin #al posto delle due righe precedenti #se ho molte chiavi posso fare così config_keys = config_interna.keys # ["tol", "maxiter", "giovanni"] # se aggiungo una nuovaChiave # ["tol", "maxiter", "giovanni", "nuovaChiave"] for i in 0...config_keys.size # for i in 0..3 # i = 1 if config[config_keys[i]] #equivalente di - if config["tol"] - usato in precedenza # k = config_keys[1] = "maxiter", config["maxiter"] config_interna[config_keys[i]] = config[config_keys[i]] # config_interna["maxiter"] = config["maxiter"] end end =end #codice che fa tante cose interessanti for i in 0..config_interna["maxiter"] #non serve a nulla! y += x end return config_interna # di un valore interessante end # fine algoritmo

14

x = 0 y = 0 c1 c2 c3 c4

= = = =

{"tol" => 1e-2, "maxiter" => 5} {"tol" => 1e-100} {"maxiter" => 1000000} {"pippo" => false}

r1 r2 r3 r4

= = = =

algoritmo(x, algoritmo(x, algoritmo(x, algoritmo(x,

y, y, y, y,

c1) c2) c3) c4)

puts r1 puts c1 puts r2 puts c2 puts r3 puts c3 puts r4 puts c4

=begin # Stampare chiavi della HASH

# IMPORTANTE

irb(main):001:0> a = {"chiave1" => 1, "chiave2" => 2} => {"chiave1"=>1, "chiave2"=>2} irb(main):002:0> a.keys => ["chiave1", "chiave2"] =end

15

#!/usr/bin/env ruby =begin ALGORITMO DI COLLATZ (Paolo) =end =begin DIVISIONE TRA INTERI 5/2=2 RESTO 5%2=1 #

- PROBLEMA -

f(n) = sistema

n/2 se n%2=0 3n+1 se n%2!=0 i appartiene 1 ... z

n(i+1) = f(ni) f(nz) = 1 tra i numeri n1 appartiene 1 ..... 10000 per lo z più grande =end puts("Esercizio in aula del 17.03.2017.") # INIZIO def divx(n) # Funzione divx() z=0 # A ogni richiamo della funzione deve riassumere il valore 0 while (n != 1) if n%2 == 0 n=n/2 else n=(3*n)+1 end z+=1 # Contatore del numero di iterazioni end return z # Numero di iterazioni avvenute per un determinato numero end ary = [] # Vettore che contiene il numero di iterazioni per ogni numero # i = 0 # Indice del vettore ary[] # zmax=0 # Posto uguale a zero per non creare problemi alla riga 60 for num in 1..10000 ##i = num-1 # Indice del vettore ary[] -> 0-based z = divx(num) # Richiamo della funzione divx() a cui è passato il valore num

16

##ary[i] = z # Nel vettore ary[] in posizione i è salvato il valore z ottenuto da divx() ary z_max z_max = z n_max = n0 end end puts "n0 = #{n_max}, z = #{z_max}" =end

20

=begin def collatz(n) return (n % 2 == 0 ? n/2 : 3 * n + 1) end def soluzione(fine) z_max = 0 n_max = 0 z_vec = [] for n0 in 1..fine n = n0 z = 0 while (n != 1) z += 1 n = collatz(n) end z_vec z_max z_max = z n_max = n0 end end return [z_max, n_max, z_vec] end ary = soluzione(10000) puts "n0 = #{ary[1]}, z = #{ary[0]}" =end =begin def collatz(n) return (n % 2 == 0 ? n/2 : 3 * n + 1) end def soluzione(fine) z_max = 0 n_max = 0 z_vec = [] for n0 in 1..fine n = n0 z = 0 while (n != 1) z += 1

21

n = collatz(n) end z_vec z_max z_max = z n_max = n0 end

# z_vec[z_vec.size] = z

end return [z_max, n_max, z_vec] end ary = soluzione(10000) #QUI È SPIEGATO COME ESEGUIRE UNA SCRITTURA RIGOROSA CON SPAZI MATRICIALI ## puts "n0 = #{'%7d'%ary[1]}, z = #{ary[0]}" -> # '%7d' % n0 -> 7 è la lunghezza e “d” indica un numero intero fl = 125.456436423631

# “f” indica un numero float

puts "#{'%9.3f'%fl}" -> # 9 elementi in totale (prima della virgola, virgola e dopo virgola) / 3 elementi dopo la virgola / il carattere f indica un numero float e garantisce la presenza della virgola puts "#{'%09.3f'%fl}"

# Stampa 0 negli spazi vuoti prima del numero

=end =begin def collatz(n) return (n % 2 == 0 ? n/2 : 3 * n + 1) end def soluzione(fine) z_max = 0 n_max = 0 z_vec = [] for n0 in 1..fine n = n0 z = 0 while (n != 1) z += 1 n = collatz(n) end z_vec z_max z_max = z n_max = n0 end end return [z_max, n_max, z_vec] end ##### zm, nm, zv = soluzione(10000) -> # Definisco 3 variabili che in ordine conterranno z_max, n_max e z_vec # # # # # # # #

irb(main):001:0> => [1, 2, 3] irb(main):002:0> => 1 irb(main):003:0> => 2 irb(main):004:0> => 3

a, b, c = [1, 2, 3] a b c

extra### puts "#{zv}" ret = ""

## Stampa tutti gli z

# Stringa vuota -> equivalente di [] per un vettore vuoto

for n0 in 0...zv.size ret # \n serve per andare a capo per creare più ordine end puts ret #####Altro metodo per ciò che è scritto sopra! Va messo dove sono i ##### def print_soluzione(zv) ret = "" for n0 in 0...zv.size ret => :ciao irb(main):002:0> => Symbol irb(main):003:0> => Fixnum irb(main):004:0> => String

:ciao :ciao.class 1.class "ciao".class

irb(main):005:0> :ciao == :ciao => true irb(main):006:0> :a == :b => false irb(main):007:0> puts "#{:a}" # La stampa di un Symbol => convertito in stringa a => nil irb(main):008:0> h = {} => {} irb(main):009:0> h[:rows] = 10 => 10 irb(main):010:0> h => {:rows=>10} =end

31

#!/usr/bin/env ruby =begin PRODOTTO TRA DUE MATRICI (Esercizio per casa) =end def prodotto(a, b) p = [] for i in 0...a.size p Nel blocco passo anche l’indice i del ciclo for def funx(ary) a = [] for i in 0...ary.size a[i] = yield(ary[i]) end return a end

# a true irb(main):003:0> random(5, (1.0)..(2.0)) => [1.8041920559265145, 1.726062020574493, 1.8178794808537833, 1.1623708781941424, 1.9508440419042703] irb(main):004:0> random(5, (1)..(2)) => [1, 1, 2, 2, 2]

48

irb(main):005:0> random(3) => [-0.0549918862533334, -0.8917348906045712, -0.7589958411946769] =end # Funzione del percettrone def neurone(x) y = 0.0 # yield # data = yield() w = data[0] b = data[1] # w, b = yield() sostituisce le 3 righe sopra for i in 0...x.size y += w[i] * x[i] end y += b return y end # Training del neurone def training(x, z, learning_rate)

# Algoritmo di Rosenblatt

w, b = yield() # 1. Inferenza di prova y = neurone(x) do [w, b] end error = z – y b = b + learning_rate * error for i in 0...w.size w[i] = w[i] + learning_rate * error * x[i] end return w, b end

49

## Costruzione problema fasullo def generazione_problema(size) n = random(3) k = random(1) dataset = [] for i in 0...size x = random(3) v = n[0] * x[0] + n[1] * x[1] + n[2] * x[2] – k x = 0 ? 1.0 : -1.0 ) dataset = 0 ? 1.0 : -1.0) # y2 è la certezza con cui sta facendo la classificazione inferenza a[i] # Il -1 corrisponde all'ultimo elemento dell'array (ciclico) k = v[y] y = i else ret x, :end => y } if not y - x < 3 x = i y = i end

end return ret end v = [1, 0, 1, 2, 2, 4, 3, 3, 3, 4, 5, 0, -1, 0, -1, 2, 50, 101, 0] ret = monotone(v) puts "#{v}" puts "#{ret}"

53

#!/usr/bin/env ruby def collatz(n) # BUBBLE_SORT CON COLLATZ return ( n % 2 == 0 ? n/2 : 3 * n + 1 ) end ary = [] for n in 1..10000 z = 0 y = n while y != 1 y = collatz(y) z = z + 1 end ary max max= ary [i] t = i + 1 end end puts ("Il numero massimo di interazioni è : #{max}") puts ("Il numero associato al massimo di iterazioni è : #{t}") # Riordinare il vettore ary -> bubble_sort def bubble_sort(ary) for j in 1...ary.size for i in 0...(ary.size - j) tmp = ary [i] if ary[i] > ary [i + 1] ary[i] = ary [i+ 1] ary [i + 1] = tmp end end end return ary end ary_ordinato = bubble_sort(ary) puts ("Vettore ordinato in modo crescente => \n #{ary_ordinato}")

54...