Pages (4): « 1 [2] 3 4 » Show 150 posts per page

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'})
    

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