Show 150 posts per page

inizo a condividere la soluzione che ho trovato per l'esercizio 1, nn assicuro nulla, anzi spero che qualcuno posti qualche altra soluzione

code:

import calendar

#Use isleap() to determine the next leap year.

year=2011
check=True

while check:
     if calendar.isleap(year):
          check=False
          print(year)
     year=year+1
     

#Find and use a function in module calendar to determine
#how many leap years there will be
#between the years 2000 and 2050, inclusive
     
print(calendar.leapdays(2000, 2051))

#Find and use a function in module calendar to determine
#which day of the week July 29, 2016 will be
print(calendar.weekday(2016, 7, 29))

code:


##Assign a list that contains the atomic numbers of the six alkaline earth metals -- beryllium (4), magnesium (12), calcium (20),
##strontium (38), barium (56), and radium (88) to a variable called alkaline_earth_metals.
##
##   1. Write code that returns the highest atomic number in alkaline_earth_metals.
##   2. Using one of the list methods, sort alkaline_earth_metals in ascending order (from the lightest to the heaviest).
##   3. Transform the alkaline_earth_metals into a dictionary using the name of the metals as the dictionary's key.
##   4. Create a second dictionary containing the noble gases -- helium (2), neon (10), argon (18), krypton (36), xenon (54), and radon (86) -- and stored in the variable noble_gases.
##   5. Merge the two dictionaries and print the result as couples (name, atomic number) sorted in ascending order on the element names.
##
##Note that Python's dictionaries do not preserve the insertion order neither it is sorted in some wa


alkaline_earth_metals=[4,12,20,38,56,88]
print (max(alkaline_earth_metals))  #1

alkaline_earth_metals.sort()
print(alkaline_earth_metals)        #2

alkaline_earth_metals_name=['beryllium', 'magnesium', 'calcium','strontium', 'barium', 'radium'] #3
metals_dict = dict(zip( alkaline_earth_metals_name, alkaline_earth_metals))
print (metals_dict)

noble_gases=dict(helium=2, neon=10, argon=18, krypton=36, xenon=54, radon=86) #4
metals_dict.update(noble_gases)
ordinamento=list(metals_dict.keys())
ordinamento.sort()
for x in ordinamento:
    print ( x, metals_dict[x])

code:

# Write a function that given a pure number prints a conversion table for it among any of the 8 scales
#(remember that functions are objects as well).


scale= dict(Kelvin=0.00 , Celsius=-273.15, Fahrenheit=-459.67, Rankine=0.0, Delisle=559.73, Newton=-90.14, Reaumur=-218.52, Romer=-135.9)

def PrintConvertionTable (temperatura):
    print ('Valore inserito %f' % temperatura)
    print ('Tabella di conversione')
    for x in scale:
        print ('( %s, %f )' % (x, scale.get(x)))
    
#Write a function that given a temperature in a specified scale returns a list of all the corresponding
#temperatures in the other scales, the list must be sorted on the
#temperature and the scale must be specified (hint: use a tuple).

def ConvertionTable (temperatura, unita):
    if unita.lower() == 'kelvin':
       Conversione=fromKelvin(temperatura)
       Ordinamento(Conversione)
       
    elif unita.lower() == 'celsius':
       Conversione=fromCelsius(temperatura)
       Ordinamento(Conversione)
        
    else:
        print('Conversione per questa scala non  implementata')

    
   

def fromKelvin (K):
    
    Kelvin=K
    Celsius= (K - 273.15 )
    Fahrenheit = (K*(9/5)-459.67)
    Rankine = K*(9/5)
    Delisle =(373.15 - K)*(3/2)
    Newton =(K - 273.15) * (33/100)
    Reaumur = (K - 273.15) * (4/5)
    Remer=(K - 273.15 )*(21/40) + 7.5
    

    conv=dict(Kelvin= Kelvin, Celsius= Celsius, Fahrenheit=Fahrenheit, Rankine=Rankine,
              Delisle=Delisle, Newton=Newton, Reaumur=Reaumur, Remer=Remer)
    return conv



def fromCelsius (C):
    
    Kelvin= C*(9/5) + 32
    Celsius=C
    Fahrenheit = C + 273.15
    Rankine = (C + 273.15)*(9/5)
    Delisle =(100-C)*(3/2)
    Newton = C*(33/100)
    Reaumur = C *(4/5)
    Remer= C* (21/40)+ 7.5
    
    conv=dict(Kelvin= Kelvin, Celsius= Celsius, Fahrenheit=Fahrenheit, Rankine=Rankine,
              Delisle=Delisle, Newton=Newton, Reaumur=Reaumur, Remer=Remer)
    return conv


def Ordinamento (ordinare):
    inverso=dict(zip(ordinare.values(),ordinare.keys())) #creo un dizionario invertando chiave valore
    ordinato=list(inverso.keys()) # creo una lista delle chiavi per poter ordinare
    ordinato.sort()
    
    for x in ordinato:         
        print(x,inverso[x])


##if __name__ == '__main__':
##
####     print (ConvertionTable(5))
##     print (Fahrenheit(5))

code:


##A matrix can be represented as a list of lists (rows and columns).
##
##   1. Use the comprehensions to describe the identity matrix (the one with all 0s but the 1s on the diagonal) of given size.
##   2. Use the comprehensions to describe a square matrix filled with the first n*n integers.
##   3. Write a function to transpose a generic matrix independently of the size and content.
##   4. Write a function to multiply two matrices non necessarily square matrix.

import copy, numpy
 
 
def IdentityMatrix (size): #1
   identity=[[1 if i==member else 0 for i in range(size)] for member in range(size)]
   return identity      

def SquareMatrix (size):   #2
   squarem=[[(member*3+1+i)*(member*3+1+i) for i in range(size)] for member in range(size)]
   return squarem    


def TransposeSquare(matrice):    #3 pero funziona solo quando la matrice è quadrata
     trasposta = copy.deepcopy(matrice)    
     for i in range(len(matrice)):  
         for j in range(len(matrice)):  
             trasposta[j][i] = matrice[i][j]  
     return trasposta
   
def Transpose(matrice): #3 usando numpy
    trasposta=numpy.matrix(matrice).T
    return trasposta

def MultiplyMatrix (m1,m2): #uso le funzionalità della libreria numpy
    a=numpy.matrix(m1)
    b=numpy.matrix(m2)
    rel=a*b
    return(rel)


if __name__=='__main__':
    
##    matrix=SquareMatrix(3)
##    print (matrix)
##    matrixT=TransposeSquare(matrix)
##    print (matrixT)##    
##    r =MultiplyMatrix (matrix,matrixT)
##    print (r)
   
      matrix=SquareMatrix(3)
      matrixT=Transpose(matrix)
      print (matrix)
      print (matrixT)

Il primo esercizio l'ho fatto uguale con la differenza che calcola il prossimo anno bisestile a partire dall'anno corrente (che rileva da una funzione base python):

code:
import datetime
import calendar

def is_leap():
  anno = datetime.date.today().year + 1
  while calendar.isleap(anno) == False:
    anno += 1
  return "Il prossimo anno bisestile e' il {0}".format(anno)

def how_many_leap():
  return calendar.leapdays(2000,2051)

def which_day():
  return calendar.weekday(2016,11,29)

Gli altri esercizi sono praticamente uguali a parte il 4 che ha qualche differenza nella moltiplicazione delle matrici (gli altri mi sembrano molto simili):

code:
import functools

def print_matrix(m):
  s = ''
  for i in range(0,len(m)):
    s += "| {0} |\n".format(m[i])
  return s
 
def id_matrix():
 try:
  size = int(input("Inserisci la dimensione della matrice: "))
  m = [[1 if(x==y) else 0 for x in range(size)] for y in range(size)]
  return "Matrice identita'\n{0}".format(print_matrix(m))
 except:
  return "Errore. Devi inserire un numero intero"

def square_matrix():
  try:
    size = int(input("Inserisci la dimensione della matrice: "))
    n = 1
    m = [[(n*(x+1))+(y*size) for x in range(size)] for y in range(size)]
    return "Matrice n*n\n{0}".format(print_matrix(m))
  except:
    return "Errore. Devi inserire un numero intero"

def trasposta_matrix(m): 
  mt = [[m[j][i] for j in range(len(m))] for i in range(len(m[0]))]
  return "Matrice\n{0}\nMatrice trasposta\n{1}".format(print_matrix(m),print_matrix(mt))

#definisco la funzione da usare con reduce()
def sum(x,y): return x+y

def moltiplicazione_matrici(m1,m2):
 try:
  if len(m1[0]) == len(m2):
    mf = []
    #con le comprehension faccio la moltiplicazione fra righe e colonne
    mf = [ [ [m1[i][j]*m2[j][x] for j in range(len(m1[0]))] for x in range(len(m2[0])) ] for i in range(len(m1)) ]
    #con programmaz. funzionale sommo i risultati dei prodotto ottenendo il risultato finale
    prodotto = [ [functools.reduce(sum, mf[i][j]) for j in range(len(mf[0]))] for i in range(len(mf)) ]
    return "Prodotto fra {0} * {1}\n{2}".format(m1,m2,prodotto)
  else:
    return "Prodotto non eseguibile"
 except:
    return "Le matrici da moltiplicare sono errate"

ecco l'ese 1.5, cmq per me sti esercizietti nn sono per niente banali o facili, e rispetto ai temi d'esame dell'anno scorso sembrano uno scherzo...
Vikyg13 hai frequentato le lezioni? io sono studentessa lavoratrice e davvero mi sembra un esame tostissimo...

code:

##Similarly to the ls-l example please implement:
##
##   1. The cat command, i.e., a command that given a list of files prints their content on the terminal (man cat to get more info).
##   2. The chmod command, i.e., a command that permits to change the access mode of a given group of files (man chmod to get more info)
##   3. The more command, i.e., a command that given a file prints its content 30 rows at a time and way a keystroke after every 30 rows to print the next 30.
##
import os, stat

def cat(filename): #1
	'''Print a file to the standard output.'''
	f =  open(filename, "r")
	flag=True
	while flag:
		line = f.readline()
		if len(line) == 0:
		    flag=False
		print (line) 
	f.close()

def more(filename): #3
	f =  open(filename, "r")
	cont=1
	flag=True
	while cont<31 and flag:
		line = f.readline()
		cont=cont+1
		if len(line) == 0:
		    flag=False
		if cont == 31:
		    k=input('[more]')
		    cont=1		    
		print (line) 
	f.close()	


		
	

if __name__=='__main__':
    cat('Matrix.py')
    os.chmod('hello.py', stat.S_ISUID) #2
    more('Matrix.py')
 

Qualcuno di voi sa perché va in overflow questo es a livello di logica l'ho riguardato mille volte ma non capisco perché dopo un po' che gira a cercare il numero divisibile per tutti i numeri da 1 a 20 sembra non trovarlo mai

code:

numerocorrente = 1
def controlladivisione():
    global numerocorrente
    divisibile = True
    for numero in [y for y in range(1,21)]:
        if numerocorrente % numero !=0:
            divisibile = False
            numerocorrente+=1
            break

    if divisibile == True:
        print(numerocorrente)
        return True

check = lambda: controlladivisione()==True or check()

if __name__ == "__main__": check()

@kirka: Ho frequentato poco. Comunque sì i temi d'esame non sono per nulla facili e anche io ho trovato ostici questi esercizi qui di laboratorio.
L'esame è tostissimo, l'anno scorso lo hanno passato veramente in pochi (mi pare soltanto in 5 in tutto l'anno). Speriamo di riuscire a passarlo prima o poi

@max: io quell'esercizio l'ho interpretato come il numero più piccolo divisibile per entrambi i numeri 1 e 20, anche perchè non so se esiste un numero divisibile per tutti i numeri da 1 a 20, credo proprio di no...
per come l'ho interpretato io la soluzione è:

code:
def es02():
  return min(filter(lambda n: n%1==0 and n%20==0, range(1,100)))

code:
for numero in range(1,21)

ecco , ma perchè quindi gli esercizi e le slide sono in inglese? per facilitarci
Io ho inteso che bisogna trovare il numero più piccolo divisibile per tutti i numeri tra 1 e 20(Calculate the smallest number divisible by each of the numbers 1 to 20)

ecco la mia soluzione all'esercizio 2.1, ho preso spunto da quihttp://www.geekality.net/garage-sale/project-euler-c/

code:

##Write the solutions for the following quizzes by using functional programming:
##
##   1. Sum all the natural numbers below one thousand that are multiples of 3 or 5.
##   2. Calculate the smallest number divisible by each of the numbers 1 to 20.
##   3. Calculate the sum of the number 2^1000
##   4. Calculate the first term in the Fibonacci sequence to contain 1000 digits.



import functools, fractions, math

somma=functools.reduce(lambda x, y:  x+y, filter(lambda x: ((x % 5 == 0) or (x % 3 == 0) ), range(1,1000))) #1
print (somma)

SmallestNumberDivisible=functools.reduce(lambda x, y: x*y/fractions.gcd(x,y), range(1,21)) #2
print (SmallestNumberDivisible)

s=functools.reduce(lambda x,y+y, list(str(2**1000))) #3
print (s)

aureo=1.6180339887 #4
fibc=lambda n: (aureo**n)/(5**(1/2))  #formula compatta e approssimativa
fib=lambda n: n if n < 2 else fib(n-1) + fib(n-2)

lunghezza=len(str(fibc(1000))) #dopo 1000 overflow e cmq dovrei andare avanti usando un ciclo trovando quello di lunghezza mille

digit=1000
n=( digit+ ((math.log(5)/2)-1) )/math.log(aureo) #formula inversa,in input la lunghezza,output digit
print (n) #2077

Direi perfette durante l'esame abbiamo a disposizione slides, documentazione e internet? perché a volte mi ritrovo a dovermi documentare su ciò che riguarda l'esercizio (es. Fibonacci) per poterlo risolvere..

Ne approfitto per aggiungere la mia visione dell'esercizio pa-es2_2 quello della frequenza delle parole nel testo:

code:

wordsandcounters = {}

def leggituttoiltesto(nomefile):
    data_file = open(nomefile, 'r')
    for line in data_file:
        words = line.rsplit(' ')
        for word in words:
            word.upper()
            if not word in wordsandcounters:
                wordsandcounters[word] = 1
            else:
                contatore = wordsandcounters.get(word)
                wordsandcounters[word] = contatore+1
    print(wordsandcounters.items())

if __name__ == '__main__':
    leggituttoiltesto('README.TXT')

La mia versione dell'es2.2
Separa la punteggiatura, mi dà qualche problema ma per le parole con l'accento, non ho trovato codifica più adatta

code:
import string, re, codecs


def split_word(input_file): return reduce(lambda x,y: x+y, [ [l.strip() for l in re.split('(\W+)', line) if l.strip() ] for line in input_file ] )
def to_lower(lst): return [elem.lower() for elem in lst]
def count_elem(lst): return dict([ (word,lst.count(word)) for word in lst ] )

def diz_tostring(d):
  s = ''
  for elem in d:
    s += '{0}= {1}\n'.format(elem,d[elem])
  return s
    

def read_count_file(f):
  input_file = codecs.open(f,'r')
  return  diz_tostring( count_elem(to_lower(split_word(input_file))) )
  input_file.close()

Ecco la mia interpretazione della funzione di Taylor per il calcolo di sinx...non ne sono sicuro al 100% ma ho seguito la regola di wikipedia e trasposta così com'era la sommatoria tramite un for...

code:

import math
from functools import reduce
import operator

def sinxtaylor(x,n):

    senx = 0
    
    for numero in range(1,n+2,2):
        print(numero)
        senx += pow(x,n)/reduce(operator.mul,[i for i in range(n,0,-1)])        
    print(senx)

if __name__ == '__main__':
    sinxtaylor(1,3)
    

Ecco la mia interpretazione dell'es1.3 degli esercizi pa-es4.html
Non mi è chiaro cosa debba modificare di questo codice per soddisfare anche la richiesta "the target should be a name containing an instance of the child class"..il file va salvato con nome pa_es4_1.py

code:

import re
'''mi basta controllare la metà della parola'''
import operator
class stringheestese:
    __metaclass__=str
    def controllapalindroma(word): #1
    
        p = re.compile(r'(\W)', re.IGNORECASE)
        word = p.sub('',word)
           
        print(word)
        
        if (len(word)%2!=0):
            '''halunghezzadispari'''
            primameta = word[0:int(len(word)/2)+1]
            secondameta= word[int(len(word)/2):int(len(word))]
        else:
            primameta = word[0:int(len(word)/2)]
            secondameta= word[int(len(word)/2):int(len(word))]
    
        secondareverse = ""
        for i in range(len(secondameta),0,-1):
            secondareverse+=secondameta[i-1:i]
    
        if secondareverse == primameta:
            print("la parola è palindroma")
        else:
            print("non è palindroma")

    def subtractletters(command): #2
        print(command.index("-"))
        word = command[1: command.index("-")-1]
        letters = command[command.index("-")+2:len(command)-1]
        p = re.compile("(["+letters+"])+")
        print("originale: "+word)
        word = p.sub('',word)
        print("rimosse le lettere "+ letters + ": " + word)

    def  dalistatrovaanagrammireciproci(dizionariodistringh
e): #3
        for current_key in dizionariodistringhe:
            '''preparo il dizionario della parola che sto analizzando con lettere e contatori'''
            tempdict1 = {}
            for letter in dizionariodistringhe[current_key]:
                '''se ce già aggiorno il contatore'''
                if letter in tempdict1:
                    tempcounter = tempdict1[letter]
                    tempdict1.pop(letter)
                    tempdict1[letter] = tempcounter+1                
                else:
                    tempdict1[letter] = dizionariodistringhe[current_key].count(letter)

            '''preparo il dizionario di ogni nuova parola e lo confronto con quello che ho gia'''
            tempdict2 = {}
            for key in dizionariodistringhe:
                if key != current_key:
                    for letter in dizionariodistringhe[key]:
                        if letter in tempdict2:
                            tempcounter = tempdict2[letter]
                            tempdict2.pop(letter)
                            tempdict2[letter] = tempcounter+1
                        else:
                            tempdict2[letter] = dizionariodistringhe[key].count(letter)

                        if tempdict1 == tempdict2:
                            print(dizionariodistringhe[current_key] +  " è l'anagramma di " + dizionariodistringhe[key])
                    tempdict2 = {}            
        
if __name__ == '__main__':
    
    import pa_es4_1
    pa_es4_1.stringheestese.controllapalindroma("gor.,... r rog")
    pa_es4_1.stringheestese.subtractletters('"Walter Cazzola"-"abcwxyz"')
    pa_es4_1.stringheestese. dalistatrovaanagrammireciproci({'test1':'ciao','te
 st2':'addio','test3':'caio','test4':'oiac','test5'
:'oddai'})
    

penso che fibo debba essere ricorsiva, così la memoizzazione ha sicuramente più senso..:

code:


def memo(f):
	'''input memoization without keyworded argument'''
	f.cache = dict()
	def decorator(*a, **k):
		t = a #, frozenset(k)
		if (t) not in f.cache:
			f.cache[ t ] = f(*a, **k)
		#else: print('cached')
		return f.cache[ t ]
	return decorator

@memo
def fib(n):
	if n==0: return 1
	if n==1: return 1

	return fib(n-1)+fib(n-2)

for i in range(10): print(fib(i))

Powered by: vBulletin Version 2.3.1
Copyright © Jelsoft Enterprises Limited 2000 - 2002.