Lezione del 7/3/2014

Riassuntino `stringhe`:

File 3.1_intro_strings.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 E.Bertolazzi e C.M. Giorgio Bort                    #
#-------------------------------------------------------------------------#

str = "Ciao mondo!"
puts str
 
# stringhe interpolate e non
str_ni = 'questa e` \n una stringa \t non interpolata'
puts str_ni
p str_ni # una stampa piu` completa
# p str_ni equivale a puts str_ni.inspect
puts str_ni.inspect
puts ""
str_i = "questa e` \n una stringa \t interpolata"
puts str_i
 
 
# interpolare variabili nelle stringhe
eta  = 5
nome = 'rex'
str_ni = 'il mio cane #{nome} ha #{eta} anni (non interpolata)'
str_ni = "il mio cane #{nome} ha #{eta} anni (si interpolata)"
puts ""
 
# concatenare stringhe
str = 'ora'
puts str
str += ' concateniamo' # equivale a str = str + ' sono'
puts str
str << " le"
puts str
str.concat " stringhe"
puts str
puts ""
 
# il punto esclamativo: alcune funzioni sono disponibili ANCHE 
# nella forma con il punto esclamativo finale. 
# In tal caso, le operazioni effettuate sulla variabile sono
# applicate direttamente su essa. 
# Convertiamo una stringa da minuscolo a maiuscolo
str = "convertimi a maiuscolo"
puts "str.upcase #{str.upcase}"
puts "str #{str}" # str e` minuscola
 
puts "str.upcase! #{str.upcase!}"
puts "str #{str}" # str e` maiuscola
puts ""
# NOTA: per vedere le funzioni di default che e` possibile 
# usare con le stringhe e` possibile digitare nell'irb: puts String.methods.sort
 
# ripetere una stringa
str = "ciao "*5
puts str
puts "\n"*2

Riassuntino `Array`

File 3.2_intro_array.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 Universita` di Trento. Tutti i diritti riservati.   #
#-------------------------------------------------------------------------#

puts 'INIZIALIZZAZIONE'
 
# array vuoto
ary  = []
ary1 = Array.new
 
# visualizza tutti i metodi nativi degli array
puts ary.methods.sort
puts "\n"
 
# controlla cos'e` ary
puts "la variabile ary e` un #{ary.class}\n"
 
# controlla se l'array e` vuoto
puts "l'array ary e` vuoto? #{ary.empty?}\n"
 
 

 
ary2 = Array.new(20)
puts "ary2 e` un array di 20 elementi, tutti nulli:\n#{ary2}\n\n"
 
# size / length (they are the same!)
puts 'Posso controllare la dimensione di ary2 con:'
puts "ary2.size ---> #{ary2.size}"
puts "ary2.length ---> #{ary2.length}"
puts ""
 
 
 
ary3 = Array.new(6, 4)
puts "ary3 e` un array di 6 elementi, tutti uguali a 4:\n#{ary3}"
puts ""
 
ary4 = Array.new(3, 'hello')
puts "ary4 e` un array di 3 elementi, tutti uguali a 'hello':\n#{ary4}"
puts ""
 
 
puts "In alternativa, posso generare un array di 'n' elementi tutti uguali a X, con il comando: [X]*n
se n=6 e X=2 scrivero` [2]*6:
#{[2]*6}"
puts ""
 
ary5 = Array(0..6)
puts "ary5 e` un array di una sequenza di numeri crescenti:\n#{ary5}"
puts ""
 
 
 
puts "_"*30
puts "CICLI NEGLI ELEMENTI DELL'ARRAY"
 
puts "a) ciclo 'for'"
for i in 0 .. ary5.length-1
  puts ary5[i]
end
 
puts "b) ciclo 'each'"
ary5.each do |e|
  puts e
end
puts "c) ciclo 'each' versione compatta"
ary5.each{ |e| puts e }
 
 
 
puts "_"*30
puts 'COPIARE ARRAY'
puts '>>> modo sbagliato:'
puts "ary5 vale #{ary5}"
 
copy_ary5 = ary5
puts "copy_ary5 vale #{copy_ary5}"
puts ''
puts "Cambio il 4(to) elemento in copy_ary5 a 999"
copy_ary5[4] = 999
puts "copy_ary5 vale #{copy_ary5}"
puts "ma ora ary5 vale #{ary5}"
puts ''
 
 
puts '>>> modo corretto:'
ary5 = Array(0..6)
puts "ary5 vale #{ary5}"
 
copy_ary5 = ary5.dup
puts "copy_ary5 vale #{copy_ary5}"
puts ''
puts "Cambio il 4(to) elemento in copy_ary5 a 999"
copy_ary5[4] = 999
puts "copy_ary5 vale #{copy_ary5}"
puts "ora ary5 vale #{ary5}"

Problema 1

Trovare i numeri perfetti minori di 1000

Definizione

Un numero perfetto è un intero uguale alla somma dei suoi divisori (escluso se stesso). Ad esempio 6 è un numero perfetto infatti i suoi divisori 1, 2, 3 hanno somma 6.

Problema 2

Trovare le coppie di numeri amicabili minori di 10000

Definizione

Una coppia di numeri interi sono detti amicabili se la somma dei divisori di primo (escluso se stesso) è uguale al secondo e viceversa. Ad esempio

• 220 è divisibile per 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 e 110 e la loro somma risulta 284;

• 284 è divisibile per 1, 2, 4, 71, 142 e la loro somma risulta 220.

quindi 220 e 284 è una coppia di numeri amicabili. Altre coppie di numeri amicabili sono 184 e 1210, 2620 e 2924, 5020 e 5564, 17296 e 18416.

Soluzione al problema 1:

File 3.3_perfect_numbers.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 Universita` di Trento. Tutti i diritti riservati.   #
#-------------------------------------------------------------------------#

=begin
 
Calcola i numeri perfetti minori di `10000`
 
Un numero perfetto e` un intero uguale alla somma dei suoi divisori (escluso se stesso).
Ad esempio 6 e` un numero perfetto infatti i suoi divisori 1, 2, 3 hanno somma 6.
 
=end
 
# numeri perfetti: 6, 28, 496, 8128, 33550336
 
#____________________________
def is_perfect?(n)
  # accumulo i divisori
  acc = 1 # 1 e` sicurmente un divisore
  for i in 2..n/2 do # se i > n/2 di sicuro non divide n
    acc += i if (n%i) == 0 # accumulo i divisori
  end
  return acc == n # se acc == n allora il numero e` perfetto
end
 
# cerco i numeri perfetti tra 1 e 10000
(1..10000).each do |n|
  puts n if is_perfect?(n)
end

Soluzione al problema 2

File 3.4_amicable_numbers.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 Universita` di Trento. Tutti i diritti riservati.   #
#-------------------------------------------------------------------------#

=begin
 
Calcola le coppie di numeri amicabili minori di `10000`
 
Una coppia di numeri interi sono detti amicabili se la somma dei 
divisori di primo (escluso se stesso) e` uguale al secondo e viceversa.
 
=end
 
nmax = 10000
 
#____________________________
def divisor_sum(n)
  # accumulo i divisori
  acc = 1 # 1 e` sicurmente divisore
  for i in 2..n/2 do # se i > n/2 di sicuro non divide n
    acc += i if (n%i) == 0 # accumulo i divisori
  end
  return acc
end
 
divisor_table = Array.new(nmax+1) ;
 
puts "costruisco tabella dei divisori"
(1..nmax).each { |n| divisor_table[n] = divisor_sum(n) ; }
 
puts "cerco numeri amicabilie perfetti"
(1..nmax).each do |n|
  m = divisor_table[n] ; # da n a m somma dei suoi divisori
  if m == n then
    puts "#{n} numero perfetto"   
  elsif m <= nmax then
    n1 = divisor_table[m] ; # n1 e` somma dei divisori di m
    # se n=n1 allora n e` somma dei divisori di m e viceversa
    puts "#{n} -- #{m}  amicabili" if n == n1
  end
end

---