#Scrivere una funzione ricorsiva che, data una lista di numeri interi (positivi o
#negativi), restituisce come risultato la somma dei valori pari contenuti nella lista. Se la lista non
#contiene valori pari, la funzione restituisce 0.

def sumIntList(L,sum):
#@ param L: list; integer list
#@ param sum: integer
#@ return: integer

  #caso base
  if len(L) == 1:
    if L[0] % 2 == 0:
      sum = sum + L[0]
      return sum
    if L[0] % 2 == 1:
      return sum
  #cso generale
  if len(L) > 1:
    if L[0] % 2 == 0:
      sum = sum + L[0]
      L = L[1:]
      return sumIntList(L,sum)
    if L[0] % 2 == 1:
      L = L[1:]
      return sumIntList(L,sum)

#Si consideri una classe Quadrato, che intende rappresentare tutti i possibili quadrati di
#lato l. La classe ha come attributo la lunghezza del lato l, e come metodi i metodi Area() e
#Perimetro() che restituiscono, rispettivamente, l'area e il perimetro del quadrato. Dare la definizione
#completa della classe, che include la definizione del suo costruttore e dei due metodi indicati.
#Fornire, inoltre, alcuni frammenti di codice Python che esemplificano l'uso della classe (creazione
#di un oggetto "quadrato", calcolo della sua area o perimetro).

class Quadrato:
  def __init__(self,lato):
  #@ param lato: integer
    self.l = lato
  def Area(self):
    area = self.l * self. l
    return area
  def Perimetro(self):
    perimeter = (self.l * 4)
    return perimeter

#Dati i seguenti due numeri:
#x = 1100110 (in base 2)
#y = 2012 (in base 3)
#determinare quale dei due ? maggiore dell'altro

# x=(1*2^6)+(1*2^5)+(0*2^4)+(0*2^3)+(1*2^2)+(1*2^1)+(0*2^0)=64+32+4+2= 102
# y=(2*3^3)+(0*3^2)+(1*3^1)+(2*3^0)=54+3+2= 59
# x > y

#Scrivere una funzione ricorsiva che, data una lista L di stringhe, restituisce come
#risultato una stringa formata dalla concatenazione di tutte le stringhe in L aventi lunghezza dispari.
#Se la lista non contiene stringhe di lunghezza dispari, la funzione restituisce la stringa vuota.

def oddStrList(L,oddList):
#@ param L: list
#@ param oddList: list
#@ return: list

  #caso base
  if len(L) == 1:
    if len(L[0]) % 2 == 0:
      return oddList
    if len(L[0]) % 2 == 1:
      oddList.append(L[0])
      return oddList
  #caso generale
  if len(L) > 1:
    if len(L[0]) % 2 == 0:
      L = L[1:]
      return oddStrList(L,oddList)
    if len(L[0]) % 2 == 1:
      oddList.append(L[0])
      L = L[1:]
      return oddStrList(L,oddList)

#Si consideri una classe Triangolo, che intende rappresentare tutti i possibili triangoli
#equilateri di lato l. La classe ha come attributo la lunghezza del lato l, e come metodi i metodi
#Area() e Perimetro() che restituiscono, rispettivamente, l'area e il perimetro del triangolo. Dare la
#definizione completa della classe, che include la definizione del suo costruttore e dei due metodi
#indicati. Fornire, inoltre, alcuni frammenti di codice Python che esemplificano l'uso della classe
#(creazione di un oggetto "triangolo", calcolo della sua area o perimetro).

class Triangolo:
  def __init__(self,lato):
  #@ param lato: integer
    self.l = lato
  def Area(self):
    altezza = (self.l * sqrt(3)) / 2
    area = (self.l * altezza) / 2
    return area
  def Perimetro(self):
    perimetro = self.l * 3
    return perimetro

#Scrivere una funzione ricorsiva che, data una stringa s, restituisce come
#risultato una stringa formata da tutti i caratteri di s separati tra loro da uno spazio bianco.

def newStr(s,newS):
#@ param s: string
#@ param newS: string
#@ return: string

  #caso base
  if len(s) == 1:
    if newS == '':
      return s
    else:
      newS = newS + ' ' + s[0]
      return newS
  #caso generale
  if len(s) > 1:
    newS = newS + ' ' + s[0]
    s = s[1:]
    return newStr(s,newS)

#Convertire in base 2 i seguenti numeri
# a = 29; b = 13
# a:    29:2=14 resto=1    14:2=7 resto=0    7:2=3 resto=1    3:2=1 resto=1    1:2=0 resto=1
# a=(11101) in base 2
# b:    13:2=6 resto=1     6:2=3 resto=0     3:2=1 resto=1    1:2=0 resto=1
# b=(1101) in base 2

#Definire in Python una classe Iterator che prende come parametro del
#costruttore una lista qualsiasi. L’Iterator permette di attraversare la
#lista in entrambe le direzioni, aggiungere e rimuovere un elemento subito
#dopo la posizione in cui si trova lungo la lista e inoltre tiene traccia della
#posizione attuale nella lista. I metodi devono essere:
#(a) hasNext : ritorna vero se esiste un elemento dopo la posizione attuale, falso altrimenti
#(b) hasPrevious: ritorna vero se esiste un elemento prima della posizione attuale, falso altrimenti
#(c) next: ritorna l’elemento successivo alla posizione attuale
#(d) previous: ritorna l’elemento precedente alla posizione attuale
#(e) add: aggiunge un elemento subito dopo la posizione attuale
#(f) remove: rimuove l’elemento subito dopo la posizione attuale e lo ritorna


class Iterator:
  def __init__(self,lista):
  #@ param lista: list
    self.lista = lista
    self.pos = 0
  def hasNext(self):
  #@ return: boolean
    if self.pos + 1 < len(self.lista):
      return true
  def hasPrevious(self):
  #@ return: boolean
    if self.pos - 1 >= 0:
      return true
  def next(self):
  #@ return: object
    if self.pos.hasNext():
      self.pos = self.pos + 1
      return self.lista[self.pos]
  def previous(self):
  #@ return: object
    if self.pos.hasPrevious():
      self.pos = self.pos - 1
      return self.lista[self.pos]
  def add(self,elem):
  #@ param elem: object
    self.lista = self.lista.insert(self.lista[self.pos + 1],elem)
  def remove(self):
  #@ return: object
    if self.lista[self.pos].hasNext():
      self.pos = self.pos + 1
      elem = self.lista[self.pos]
      self.lista.pop(self.lista[self.pos])
      return elem

#Scrivere una funzione ricorsiva in Python che, dati due interi positivi a e b, calcola a^b


def potenza(a,b,p=0):
#@ param a: integer
#@ param b: integer
#@ param p: integer
#@ return: integer

  #caso base
  if b == 1:
    return a
  if b == 0:
    return 1

  #caso generale
  if b >= 2 and p == 0:
    p = a
    a = a * a
    b = b - 1
    return potenza(a,b,p)
  if b >= 2:
    a = p * a
    b = b - 1
    return potenza(a,b,p)