alex/exercitii
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Am adaugat materialele din săpt trecute.

Browse Source
This commit is contained in:
Alexandru Tofănel
2026-03-27 21:15:27 +02:00
parent 16f3a6aaed
commit 84453a6456
23 changed files with 1634 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
python/curs/curs2_intro_sintaxa.py
+203
View File
@@ -0,0 +1,203 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 25 15:17:23 2026
@author: alex
"""
import math
luna = 13
permis = 1 <= luna <=12
print(permis)
s1 = "Matematica"
s2 = "info"
s3 = """Prima
linie"""
print ("Ana" + " " "Pop")
print ("=" * 20)
print(len("Matematica"))
print("mat" in "Matematica")
s = "string"
s = 'A' + s[1:]
print (s)
s = "Matematica"
print(s[0])
print(s[4])
print(s[-1])
print(s[-3])
#slicing s[start:stop:pas]
print(s[0:4])
print(s[4:])
print(s[:4])
print(s[::2])
s ="Buna ziua! "
t = s.strip()
print(t)
t = s.upper()
print(t)
t = s.lower()
print(t)
t = s.replace('ziua','dimineata')
print(t)
x = 1
if x>0:
print('pozitiv')
print('si real')
print('mereu')
raza = float(input("raza: "))
pi = math.pi
aria = pi*raza**2
circum = 2*pi*raza
print(f"aria este: {aria:.4f} m patrati")
print(f"circumferinta este: {circum:.4f} m")
n = int(input("n: "))
if n == 0:
print("n este 0")
else:
if n > 0:
semn = "pozitiv"
elif n < 0:
semn = "negativ"
if n % 2:
print(f"{n} este par si {semn}")
else:
print(f"{n} este impar si {semn}")
n = 100
suma = 0
for i in range(1, n+1):
suma += i
print(suma)
print(n*(n+1) // 2)
for i in range(5, 0, -1):
print(i, end = ' ')
for litera in "Math":
print(litera)
a = int(input('a= '))
b = int(input('b= '))
while b != 0:
a, b = b, a % b
print (f"cmmdc = {a}")
numar = int(input("numarul este "))
card = int(0)
while numar != 0:
numar //= 10 #doua // inseamna /
card = card +1
print (f"numarul de cifre al numarului este {card}")
x = int(input("x = "))
if x > 0:
print("pozitiv")
if x > 100:
print("mare")
numar_intreg = 42
numar_real = 3.14159
numar_complex = 3 + 4j
text = "matematica"
adevarat = True
print(type(numar_intreg))
print(type(numar_real))
print(type(numar_complex))
print(type(text))
print(type(adevarat))
z1 = 3 + 4j
z2 = 1 - 2j
print(z1.real)
print(z1.imag)
print(abs(z1))
print(z1+z2)
print(z1*z2)
print(z1.conjugate())
n = int(input("Numar: "))
print(n+1)
nume = "Ana"
varsta = 20
medie = 9.75
print("Studentul " + nume + " are " + str(varsta) + " ani ")
print(f"Studentul {nume} are {varsta} ani.")
print(f"Peste 5 ani {nume} va avea {varsta + 5} ani.")
print(f"Dublul mediei este {2 * medie}")
pi = math.pi
print(f"pi = {pi:.2f}")
print(f"pi = {pi:.5f}")
numar_mic = 0.000001234
print(f"{numar_mic:.3e}")
n = 1000000
print(f"{n:,}")
p = 0.8765
print(f"{p:.1%}")
for i in range(1,6):
print(f"{i:3d} | {i**2:5d} | {math.sqrt(i):.4f}")
x = float(input("Introdu un numar real: "))
if x > 0:
print(f"{x} este pozitiv")
elif x < 0:
print(f"{x} este negativ")
else:
print("Numarul este zero")
n = 10
suma = 0
for i in range (1,n+1):
suma += i
print(f"Suma 1+2+3+...+{n} = {suma}")
formula = n * (n + 1) // 2
print(f"Formula lui Gauss: n*(n+1)/2 = {formula}")
n = int(input("Introdu un numar intreg pozitiv: "))
nr_cifre = 0
temp = n
while temp > 0:
temp //= 10
nr_cifre += 1
print(f"Numarul {n} are {nr_cifre} cifre")
n = int(input("n: "))
for i in range(1,n+1):
if type(math.sqrt(i)) == int(math.sqrt(i)):
print(f"{i:3d} | {i**2} | {math.sqrt(i):.8f}")
python/curs/curs3_functii.py
+131
View File
@@ -0,0 +1,131 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 4 14:39:09 2026
@author: alex
"""
import math
#functii
def expr(a, b):
return (a*a - b*b)/(a + b)
def este_prim(n):
if n < 2:
return False
for i in range (2, int(n**0.5 + 1)):
if n%i == 0:
return False
return True
def putere(x, p=2):
return x**p
#p=2 val default, param def la final
def f(a,b,c=0):
return a + 10*b +100*c
def adauga(x, lista=None):
if lista is None:
lista = []
lista.append(x)
return lista
def impartire(a,b):
cat = a//b
rest = a%b
return cat,rest
def aplica(f, lista):
rezultat = []
for x in lista:
rezultat.append(f(x))
return rezultat
def gdc(a, b):
if b == 0:
return a
return gdc(b, a % b)
def fact(n):
if n <=1: # conditie
return 1
return n * fact(n-1) # pas recursiv
def fact_it(n):
p = 1
for k in range(2,n+1):
p *= k
return p #nerecursiv
print(expr(10,5))
print(este_prim(3))
print(putere(3)) #functie cu puterea 2 default
print(f(1,2,c=3)) #exemplu parametrii
print(f(1,2,3))
lista=[1,2,3]
adauga(4,lista)
print(lista)
c, r = impartire(17,5)
print(c,r)
valori = [0, 1, 4, 9, 16]
print(aplica(math.sqrt, valori)) # functia este paramentrul altei functii sus
print(gdc(2, 9))
print(fact(10))
print(fact_it(10))
#functii de o linie lambda
patrat = lambda x: x*x
print(patrat(5))
semn = lambda x: -1 if x < 0 else 1
print(semn(-7),semn(3))
numere = [1, 4, 9, 16, 25]
radacini = list(map(math.sqrt, numere)) #map prelucreaza lista si transforma
#fiecare element al listei, transformare in-place / map(f, [a,b,c]) => [f(a), f(b), f(c)]
#nu are legatura cu structura map din c++
print(radacini)
pare = list(filter(lambda x: x%2 == 0, range(10)))
#filtreaza
print(pare)
numere1= list(range(10))
pare1 = list(filter(lambda x: x%2 == 0, numere1))
# filter(p, [a,b,c]) p = paramentrul de filtrare i.e. functie cu return
print(pare1)
#Recursivitate
print(fact(5))
#Comprehensions: metoda const o colectie (lista/dict/set) dintr-un iterabil
#folosind for si optional if
#lista = []
#for x in A: lista.append(expresie)
#eq
#[expresie for x in A]
patrate = [x*x for x in range(10)]
print(patrate)
patrate_pare = [x*x for x in range(10) if x%2 == 0]
print(patrate_pare)
func = lambda x: x*x - 5*x + 6
sol = [x for x in range (-10, 11) if func(x) < 0]
print(sol)
#list map filter comprehensions diferente
#list(map(f,A)) ... [f(x) for x in A]
#list(filter(p,A)) .. [x for x in A if p(x)]
#list(map(f, filter(p,A))) ... [f(x) for x in A if p(x)]
python/curs/curs4_array.py
+214
View File
@@ -0,0 +1,214 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 11 14:12:41 2026
@author: alex
"""
# lista
x1 = 3
x2 = 7
x3 = 10
x4 = 12
print (x1 + x2 + x3 + x4)
valori = [3,7,10,12]
print(sum(valori))
# tipuri: liste, tuple, set ,dictionar
# lista col ord mod; tuple col ord nemod
# set col fara duplicate
# dic - map C++
# ordonate =/= sortate; pastreaza ordinea data
# lista -> vector nr. ex
note = [7,8,9,10]
print(note)
date = [3,4.5,"Ana"]
print(date)
print(note[0])
print(note[2])
print(note[-1])
print(note[-4])
note = [7, 8, 9]
note[1] = 10
print(note)
valori = [1,2,3]
valori.append(4)
print(valori)
valori.remove(2) # sterge 2 din lista, nu indexul 2
print(valori)
x = valori.pop() # scoate ultimul si da return
print(x)
print(valori)
note = [7,8,9,10]
for n in note:
print(n)
# Exercitii
#1
lista = []
for i in range(1,11):
lista.append(i)
print(sum(lista))
print(lista)
elemente = [2, 5.6, "Text"]
print(elemente[-1])
print(elemente[-2])
elemente[-1] = 7
print(elemente[-1])
#Tuple
#paranteze rotunde, nu se modifica, pot avea oricate elemente
punct = (2,5)
data = ( 15, 3, 2005)
culoate = (0,0,0)
#accesarea
print(data[0])
print(data[1])
print(data[2])
punct=(2,5)
#punct[0] = 1 EROARE
def impartire(a,b):
cat = a // b
rest = a % b
return(cat,rest)
print(impartire(2,3))
coordonate = (2,5)
print(coordonate)
print(f"abscisa: {coordonate[0]}, ordonata: {coordonate[1]} ")
c = (5, coordonate[1])
coordonate = c
coordonate = (coordonate[0], 3)
print(coordonate)
#Seturi
#fara duplicate, ordine neimportatnta, operatii cu multimi
A = {1,2,3,3,4}
print(A)
A = {1,2,3}
B = {3,4,5}
print(A | B) #reuniune
print(A & B) #intersect
print(A - B) #dif
cuvant = "matematica"
litere = set(cuvant)
print(litere) #ordinea nu se pastreaza
litere1 = set("matematica")
litere2 = set("informatica")
print(litere1)
print(litere2)
print(litere1 | litere2)
print(litere1 & litere2)
print(litere1 - litere2)
print(litere2 - litere1)
#Dictionar
# cheie -> val
note = {
"Ana": 10,
"Ion": 8,
"Maria": 9
}
print(note["Ana"])
note = {"Ana": 10, "Ion": 8}
note["Maria"] = 9
note["Ion"] = 10
print(note)
for nume, nota in note.items():
print(nume,nota)
note = [7,8,9,10]
print(len(note)) # lungime
print(8 in note) # search function
print(5 in note)
valori = [10,20,30,40,50,60]
print(valori[1:4]) #slicing; ultima val nu e inclusa
print(valori[:3])
print(valori[3:])
print(valori[::2]) #din 2 in 2 (al 3lea parametru)
note = [7,8,9,10]
for n in note: # i.e. for each
print(n)
for i in range(len(note)): # for range
print("index =", i, "valoare = ", note[i])
for i, x in enumerate(note): # echivalent cu ^
print(i, x)
#sort + reverse
valori = [7,2,9,1,5]
valori.reverse()
print(valori)
valori.sort()
print(valori)
valori.reverse()
print(valori)
# = sorted()
valori = [7,2,9,1,5]
copie_sortata = sorted(valori)
print(valori)
print(copie_sortata)
print(valori.count(2))
print(valori.count(3))
print(valori.index(2))
note = {"Ana": 10, "Ion":8 }
print(note.keys())
print(note.values())
print(note.items())
print("Ana" in note)
print("Maria" in note)
valori = [10,20,30]
#print(valori[3]) EROARE in afara listei
note = {"Ana": 10, "Ion":8 }
#print(note["Maria"]) EROARE pt. ca cheia nu exista in dictionar
a = {} #nu creaza multime vida; ci dic vid
b = set() #creaza multime vida
print(type(a))
print(type(b))
note =[7,8,9,10]
media = sum(note) /len(note)
print(media)
valori = [1,2,2,3,4,4,4,5] #transforma lista in set, i.e se elimina duplicate
distincte = set(valori)
print(distincte)
tabel = {} # asociaza elemente din domeniu in codomeniu
for x in range (-2,3): # util pentru functii ex. x -> x^2 + 1
tabel[x] = x*x +1
print(tabel)
python/curs/curs5_np_ndarray.py
+257
View File
@@ -0,0 +1,257 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 18 14:16:17 2026
@author: alex
"""
import numpy as np
#ndarray
def delimit(i):
print(" ")
print(f"-({i})-" + 48*"-")
delimit(0)
x = [1, 2, 3, 4]
# fara numpy
rez = []
for t in x:
rez.append(t*t + 1)
print(rez)
# cu numpy
x = np.array([1, 2, 3, 4])
rez = x * x + 1
print(rez)
delimit(1)
a = np.array([1, 2, 3])
b = np.zeros(4) # 4 zerouri
print(np.mean(a))
a = np.array([1, 2, 3, 4])
print(a)
print(type(a)) #ndarray
delimit(2)
A = np.array([[1,2,3],
[4,5,6]])
print(A)
print(A.shape)
print(A.ndim)
delimit(3)
L1 = [1,2,3]
L2 = [4,5,6]
print(L1+L2) #concatenare
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a+b) #adunare vectoriala
print(L1*2) #dublare lista
print(a*2) #inmultire cu scalar
delimit(4)
a = np.array([1, 2, 3])
b = a * a + 1
print(a)
print(b)
delimit(5)
a = np.array([[1, 2, 3]]) #matrice de o linie si 3 coloane
print(a.shape) #(linii, coloane)
a = np.array([1,2,3]) # matrice de 3 linii si '0' coloane
# a doua forma e transpusa primei si viceversa
print(a.shape)
b = a + a + 1 # exhivalent cu b = 2*a + 1
print(a)
print(b)
print(b-a)
delimit(6)
c = np.array([[1,2,3],
[4,5,6]])
print(c)
print(c.shape)
delimit(7)
lista = [1,2,3]
#print(lista + 1 ) # EROARE
lista2 = [1]
print(lista + lista2) #corect
print(lista + [6]) # corect
delimit(8)
x = [0,1,2,3]
y = []
for t in x:
y.append(t**2 + 1)
print(y) #explicit
y = [t**2 + 1 for t in x]
print(y) #list comprehensions
x = np.array([0,1,2,3])
y = x**2 + 1 #array in numpy
print(y)
# echivalente ^
delimit(9)
a = np.array([10,20,30,40])
print(a)
print(a.shape) # 4 linii 1 col (4,)
print(a.size) # numarul de elemente
print(a.dtype) # tipul elementelor i.e. int64
print(a.ndim) # numarul de dimensiuni ale array-ului
delimit(10)
c = np.array([[1,2,3],
[4,5,6]])
print(c)
print(c.shape)
print(c.size)
print(c.dtype)
print(c.ndim)
delimit(11)
#tip date int si float
a = np.array([1, 2, 3])
b = np.array([1., 2., 3.])
b_1 = np.array([1., 2, 3.])
print(a.dtype)
print(b.dtype)
print(b_1.dtype)
delimit(12)
a = np.zeros(5) # 5 zerouri
b = np.ones(4) # 4 de 1
c = np.arange(0, 10, 2) # A RANGE de la 0 la 10 din 2 in 2 (pas);
# 10 nu e luat in calcul
d = np.linspace(0, 1, 5) # multime de la 0 la 1 cu 5 elemente echidistante
# se foloseste pentru a crea domeniul unei functii pe interval
print(a)
print(b)
print(c)
print(d)
delimit(13)
# operatii vectorizate
a = np.array([1,2,3])
print(a + 1)
print(a - 1)
print(a / 2)
print(a // 2)
print(2 * a)
b = np.array([4,5,6])
print(a + b)
print(b - a)
print(b / a)
print(a * b)
c = np.array([1,2,3])
d = np.array([10,20])
#print(c+d) # EROARE, array-urile trebuies sa fie de marime egala
delimit(14)
a = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2])
print(np.sin(a))
print(np.cos(a))
#face aproximari a lui pi si deci cos(pi/2) nu e exact 0
delimit(15)
y = np.array([1,1,4,9,16,16])
print(np.sqrt(y))
print(np.min(y))
print(np.max(y))
print(np.argmin(y)) # prima pozitie la care apare min
print(np.argmax(y)) # prima pozitie la care apare max
# indexate de la 0
print(np.where(y == np.min(y)))
#gaseste toate pozitiile la care se gaseste elementul care
#satisface conditia ex. min
print(np.sum(y)) # suma
print(np.mean(y)) # media
print(np.std(y)) # eroarea medie statistica
n = np.array([-1,-1,-4,-9,-16,-16,1,1,4,9,16,16])
print(np.abs(n)) # modul
a = np.array([4,7,2,9,10])
print(np.sort(a))
print(a) # nu modifica pe loc variabila
delimit(16)
L = [1, 2, 3, 4]
a = np.array(L)
print(L)
print(a)
print(type(L))
print(type(a))
L_1 = a.tolist()
print(L_1)
print(type(L_1))
delimit(17)
# Exemplu de program numpy.array vs list + for
temperaturi = [10,15,30,40]
temperaturi_f = []
for temp in temperaturi:
temperaturi_f += [(temp * (9/5) + 32)]
print(temperaturi_f)
temperaturi = np.array([10,15,30,40])
temperaturi_f = temperaturi * (9/5) + 32
print(temperaturi_f)
python/curs/curs6_matrice.py
+294
View File
@@ -0,0 +1,294 @@
# -*- coding: utf-8 -*-
import numpy as np
#NumPy avansat
def delimit(i):
print(" ")
print(f"-({i})-" + 48*"-")
delimit(0)#################################################################
v = np.array([1,2,3,4,5,6])
print(v[0])
print(v[2])
print(v[-1])
print(v[1:4]) # de la 1 pana inainte de 4
print(v[:3]) # pana inainte de 3
print(v[3:]) # de la 3
print(v[::2]) # pas
delimit(1)#################################################################
L = [1,2,3,4,5,6]
L[1:4] = [0,0,0] # atribuie lista; L[1:4] = 0 gresit
print(L)
v[1:4] = 0 # atribuie scalar direct
print(v)
delimit(2)#################################################################
A = np.array([[1,2,3],
[3,4,6],
[7,8,9]])
print(A)
print(A.ndim)
print(A.size)
delimit(3)#################################################################
Z = np.zeros((2,3))
O = np.ones((3,2))
I = np.eye(3)
print(A)
print(O)
print(I)
delimit(4)#################################################################
a= np.arange(1,7)
A = a.reshape(2,3)
print(a)
print(A)
delimit(5)#################################################################
A = np.array([[1,2,3],
[3,4,6],
[7,8,9]])
print(A[0,0]) # extrage element
print(A[1,2])
print(A[2,1])
print(A[1,:]) # extragere de linii; linia a doua
print(A[:, 0]) # extrage coloana 1
A = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12]])
print(A[0:2, 1:3]) #extrage submatrice taind 0:2 pe linii si 1:3 pe col
delimit(6)#################################################################
# Operatii cu matrice in NumPy
#A*B nu inseamna in general produs matricial
A = np.array([[1,2],
[3,4]])
B = np.array([[1,2],
[3,4]])
print(A+B)
print(A-B)
# A * B
print(A * B) # element cu element nu matricial
# A @ B
print(A @ B) # inmultire normala
# Inmultirea cu scalar
print(3 * A)
# alte operatii
print(A.T) # transpusa
print(np.linalg.inv(A)) # inversa cu .inv din sublibraria .linalg
print(A^(-1)) # matricea cu inversele per element
delimit(7)#################################################################
# Broadcasting
# combina automat array-uri cu forme diferite, extinzand implicit o dim.
# pentru a face operatia posibila
# functioneaza doar atunci cand formele array-urilor sunt compatibile
A = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
v = np.array([1,2,3]) #vector linie
print(A+10) # scalarul 10 este extins la forma matricei ex. (3x3)
print(A + v) # vectorul (:1) este extins la forma 3x3 i.e adauga vectorul
# pe cate numere sunt necesare
u = np.array([[10],
[20],
[30]]) # vector coloana
print(A + u)
print(u+v) # adunare vector linie cu vector coloana
# extinde vectorul coloana in asa fel sa se potriveasca cu numarul de col
# a vectorului linie, si analog extinde vectorul inie i.e. (1x3) + (3x1) = (3x3)
# dimensiunea vec col = dim vec linie pentru ca numpy sa nu dea EROARE
# broadcasting-ul functioneaza cand dim matricilor sunt egale sau cand
# una dintre dimensiuni este 1.
delimit(8)#################################################################
A = np.array([[1, 2, 3],
[4, 5, 6]])
print(np.sum(A))
print(np.min(A))
print(np.max(A))
print(np.mean(A))
# functiile de mai sus se fac cu toate elementele matricei
#sume pe linie sau coloana
print(np.sum(A, axis=0)) #return matrice cu sume per coloane
print(np.sum(A, axis=1)) #return matrice cu sume per linii
print(np.mean(A, axis=0)) #return matrice cu medii per coloane
print(np.mean(A, axis=1)) #return matrice cu medii per linii
print(np.max(A, axis=0)) #return matrice cu maxime de pe coloane
print(np.max(A, axis=1)) #return matrice cu maxime de pe linii
print(np.min(A, axis=0)) #return matrice cu minime de pe coloane
print(np.min(A, axis=1)) #return matrice cu minime de pe linii
#axis = 0 coloane
#axis = 1 linii
delimit(9)#################################################################
# A de mai sus
rang_A = np.linalg.matrix_rank(A)
print(rang_A) # merge chiar daca matricea nu e patratica; rang deltaP
A = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
print(A)
det_A = np.linalg.det(A)
print(det_A)
#A_inv = np.linalg.inv(A)
#print(A_inv) # det matricei de mai sus este 0 si nu are inversa
A_2 = np.array([[1,2,1],
[4,5,6],
[7,8,9]])
det_A_2 = np.linalg.det(A_2)
print(det_A_2)
A_2_inv = np.linalg.inv(A_2)
print(A_2_inv)
rang_A_2 = np.linalg.matrix_rank(A_2)
print(f"Rangul matricei A_2 (3x3) cu determinantul {det_A_2} este {rang_A_2}")
A = np.array([[2,1],
[1,3]])
b = np.array([1,2]) #solve
print("Solutiile sistemului de ecuatii sunt: ", np.linalg.solve(A,b))
A = np.array([[1,2],
[3,4]])
A_inv = np.linalg.inv(A)
print(A @ A_inv) # inversa se face prin aproximari deci inmultirea nu o sa
# de matricea unitate;
# din acest motiv nu comparam direct matrici cu elemente de tip float folosind ==
# in schimb folosim np.allclose() sa vedem daca elementele sunt apropiate
print(A == A_inv)
A = np.array([[1,0,0],
[0,1,0],
[0,0,1]])
A_inv = np.linalg.inv(A)
print(A)
print(A_inv)
print(A.T)
simterica = np.allclose(A, A.T)
I = np.eye(A.shape[0]) # .shape() are output un tuple cu dimensiunile [0] scoate
# numarul liniilor, iar eye creaza mat. identitate de
# dimensiunea respectiva
print(I) # float-uri
print(A) # inturi
print(I == A) # elementel din matrice sunt egale intre ele => matrice 3x3 de True
print(A == A_inv) # in cazul asta e True, dar mai sus e un exemplu pentru care
# aproximarile float al inversei cu val reale a inversei ar da False
ortogonala = np.allclose(A, A_inv) # true
print(ortogonala) # matricea identitate este egala cu inversa ei
delimit(10)#################################################################
a = np.array([1,2,7,1,9,5,8,9])
print(a)
print(np.where(a == 1)) # vector print unde el. = 1
A = np.array([[4,2,7],
[1,5,1],
[3,6,8]])
poz = np.where(A == 1)
print(A)
print(poz) # pozitiile pentru care elementul din a este 1
print(poz[0]) # randurile pe care se gasesc
print(poz[1]) # coloanele pe care se gasesc
for row, col in zip(*poz):
print(f"({row}, {col})")
# zip(*poz) face perechi element cu element din lista de tuples de tipul i,j
# altfel coordonatele sunt in doua liste separate
delimit(11)#################################################################
col = np.array([0,2,0,2,2,1])
print(np.unique(col)) # pastreaza din array doar elementele care sunt distincte
mat = np.array([[0,2,0],
[2,2,1]]) # pe matrice o forteaza intr-un vector si da return
print(np.unique(mat)) # elementelor distincte
delimit(12)#################################################################
# Problema, se da o matrice sa se determine coloanele pe care apare val min din
#matrice iar pe aceste coloane sa se adauge o constanta c. (cu np.where)
c = 10
minim = np.min(A)
linii, coloane = np.where(A == minim) #coloanele unde exista min
coloane_unice = np.unique(coloane) #elimina duplicate pentru nu a aduna c
#de doua ori
A_nou = A.copy()
A_nou[:, coloane_unice] += c
#^merge pe fiecare linie pe coloanele din vectorul de coloane unice
print("Minimul:", minim)
print("Linii: ", linii)
print("Coloane: ", coloane)
print("Coloane distincte:", coloane_unice)
delimit(13)#################################################################
# Se da o matrice A. Sa se determine coloanele in care apare valoarea maxima
# din matrice , iar toate elementele de pe aceste coloane sa fie inlocuite cu 0.
maxim = np.max(A)
linii, coloane = np.where(A == maxim)
coloane_unice = np.unique(coloane)
A_nou = A.copy()
A_nou[:, coloane_unice] = 0
print("Maximul: ", maxim)
print("Coloane unice: ", coloane_unice)
print("Matricea modificata: ")
print(A_nou)
python/curs/notare
+4
View File
@@ -0,0 +1,4 @@
examen 30%
test lab 30%
proiect final 30%
activitate 10%
python/extra/bday_messages.py
+17
View File
@@ -0,0 +1,17 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 21 18:28:22 2026
@author: alex
"""
import random
import pandas
bday_messages = ['Hope you have a very Happy Birthday! 🎈',
'It\'s your special day – get out there and celebrate! 🎉',
'You were born and the world got better – everybody wins! 🥳',
'Have lots of fun on your special day! 🎂',
'Another year of you going around the sun! 🌞'
]
bday_m = random.choice(bday_messages)
python/extra/intro.py
+33
View File
@@ -0,0 +1,33 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 11 17:21:24 2026
@author: alex
"""
for bottles in range(99,0,-1):
print(f"{bottles} bottles of beer on the wall")
print(f"{bottles} bottles of beer")
print("Take one down, pass it around")
for i in range (1,101): #fizzbuzz
if (i%3==0 and i%5==0):
print("FizzBuzz")
elif (i%3==0):
print("Fizz")
elif (i%5==0):
print("Buzz")
else:
print(i)
def exp(a,b):
p = 1
if(b<1):
return p
else:
p *= exp(a,b)
b = b -1
print(exp(2,2))
python/extra/main.py
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 21 18:27:40 2026
@author: alex
"""
import datetime, bday_messages
today = datetime.date(2026,3,21)
next_birthday = datetime.date(2026,5,13)
time_difference = next_birthday - today
if time_difference == 0:
print(bday_m)
else:
print(f"My next birthday is {time_difference} days away!")
python/python_syntax/classes_and_methods.py → python/extra/python_syntax/classes_and_methods.py
View File
python/python_syntax/random_module.py → python/extra/python_syntax/random_module.py
View File
python/laborator/lab3.py
+42
View File
@@ -0,0 +1,42 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 6 14:12:20 2026
@author: alex
"""
#functii
def este_prim(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n%i == 0:
return False
return True
def cmmdc(a, b):
a, b = abs(a), abs(b)
while b != 0:
a,b = b, a % b
return a
def cmmc(a, b):
if a == 0 or b == 0:
return 0
return abs(a * b) // cmmdc(a, b)
#cod
#for n in [1, 2, 3 ,4, 17, 18, 97, 100]:
# stare = "prim" if este_prim(n) else "compus"
# print(f"{n:3d} este {stare}")
perechi = [(12, 8), (100, 75), (17,13), (48, 36)]
print(f"{'a':>5} {'b':>5} {'CMMDC':>8} {'CMMC':>8}")
print("-" * 30)
for a, b in perechi:
print(f"{a:>5} {b:>5} {cmmdc(a, b):>8} {cmmc(a, b):>8}")
python/laborator/lab3_2.py
+95
View File
@@ -0,0 +1,95 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 6 14:36:50 2026
@author: alex
"""
import math
def putere(a, n):
p = 1
if n < 1:
return p
return a*putere(a, n-1)
def putere_it(a, n):
p = 1
for i in range (1, n+1):
p = p*a
return p
def factorial(n):
f = 1
for i in range(1, n+1):
f = f*i
return f
def comb(n, k):
return factorial(n) // (factorial(k) * factorial(n - k))
def cifre_pare(n):
n = abs(n)
cif_pare = 0
while n!= 0:
if( (n%10)%2 == 0 ):
cif_pare += 1
n //= 10
return cif_pare
def produs_div3(n):
p=1
while (n != 0):
cifra = int(n%10)
print(cifra)
if (cifra % 3 == 0):
p *= cifra
n //= 10
return p
def lungime(n):
i = 0
while n > 1:
n //= 10
i += 1
return i
def oglindit(n):
og = 0
while n != 0:
og += putere(10,lungime(n)) * int(n%10)
n //= 10
return og
def oglindit_2(n):
ogl = 0
while n!= 0:
ogl = ogl * 10 + n%10
n //= 10
return ogl
def parab(x):
return x*x
def integreaza(f, a, b, n=1000):
h = (b - a) / n
integr = 0
for i in range(n):
x = a + i*h
integr += f(x) * h
return integr
#print(putere(2, 10))
#print(putere_it(2, 10))
#print(factorial(5))
#print(comb(5, 2))
#print(cifre_pare(2486135))
#print(cifre_pare(2222222))
#print(produs_div3(39162))
#print(lungime(24))
#print(oglindit(123))
#print(oglindit_2(123))
print(integreaza(parab, 0, 1,10000))
print(integreaza(math.sin, 0, math.pi))
python/laborator/lab4/1.py
+7
View File
@@ -0,0 +1,7 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 11 14:12:41 2026
@author: alex
"""
python/laborator/lab4/2.py
+26
View File
@@ -0,0 +1,26 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:16:54 2026
@author: alex
"""
#Lab 4
note = [7, 8, 9, 10]
puncte = [(1,2), (3,4, (5,6))]
print(note[0])
print(note[-1])
print(note[-2])
v = [10, 20, 30, 40, 50, 60, 70, 80]
print(v[2:5])
print(v[:5])
print(v[::2])
print(v[::-1])
note = [7,8,9,10]
for i, val in enumerate(note):
print(f"{i} {val}")
python/laborator/lab4/untitled2.py
+27
View File
@@ -0,0 +1,27 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:28:27 2026
@author: alex
"""
def inverseaza(lista):
lung = len(lista)
inv = []
for i in range(0,lung):
inv.append(lista[lung-1-i])
return inv
lista = [1,3,4,2,5,6]
print(lista)
lista = inverseaza(lista)
print(lista)
def inverseaza_2(lista):
lista_2 = []
for n in lista:
lista_2.insert(0,n)
return lista_2
lista = inverseaza_2(lista)
print(lista)
python/laborator/lab4/untitled3.py
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:38:04 2026
@author: alex
"""
#def comune(A,B):
# intrare = ""
# print("adauga in A: ")
# while intrare != -1:
# intrare = input()
# A.append(intrare)
# print("adauga in B: ")
# A = int(A)
# while intrare != -1:
# intrare = input()
# B.append(intrare)
# B = int(B)
# print(A)
# print(B)
#
#A = []
#B = []
#comune(A,B)
def comune(A,B):
A = set(A)
B = set(B)
intersectia = A & B
intersectia = list(intersectia)
intersectia.sort()
return intersectia
A = [1,2,3,4,4]
B = [3,4,5,6,7]
C = comune(A,B)
print(C)
python/laborator/lab4/untitled4.py
+17
View File
@@ -0,0 +1,17 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:49:16 2026
@author: alex
"""
# Scrie o functie rotire lista k care roteste lista circular la dreapta cu n elemente
def rotire(lista, k):
lista_2 = []
for i in lista:
lista_2=lista[k+1:] + lista[:-k]
return lista_2
lista =[1,2,3,4,5]
lista = rotire(lista,2)
print(lista)
python/laborator/lab4/untitled5.py
+16
View File
@@ -0,0 +1,16 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 14:55:47 2026
@author: alex
"""
def inverseaza_dict(d):
d_2 = dict()
for k, el in d.items():
d_2[el]=k
return d_2
D = {"a":1 , "b":2, "c":3}
D = inverseaza_dict(D)
print(D)
python/laborator/lab4/untitled6.py
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 15:06:25 2026
@author: alex
"""
def cel_mai_frecvent(lista):
frec = [0] * (max(lista) + 1)
for n in lista:
frec[n] += 1
maxim = 0
for i in range(len(frec)):
if frec[i] > maxim:
maxim = frec[i]
el = i
return el
lista = [1, 3, 2, 3, 1, 3, 2]
print(max(lista))
print(cel_mai_frecvent(lista))
python/laborator/lab4/untitled7.py
+41
View File
@@ -0,0 +1,41 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 15:24:08 2026
@author: alex
"""
def cel_mai_frecvent(lista):
frec = [0] * (max(lista) + 1)
for n in lista:
frec[n] += 1
maxim = 0
for i in range(len(frec)):
if frec[i] > maxim:
maxim = frec[i]
el = i
return el
def frecventa(lista):
rezultat = {}
for x in lista:
if x in rezultat:
rezultat[x] += 1
else:
rezultat[x] = 1
return rezultat
lista = [1, 3, 2, 3, 1, 3, 2]
print(max(lista))
print(cel_mai_frecvent(lista))
note = [7,8,9,7,10,8,7,9,9,10,1]
freq = frecventa(note)
print(freq)
for nota,cnt in sorted(freq.items()):
print(f"Nota {nota}: aparede {cnt} ori")
python/laborator/lab4/untitled8.py
+22
View File
@@ -0,0 +1,22 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 13 15:34:19 2026
@author: alex
"""
def f(x):
return x*x -3*x +2
tabel = {}
for x in range(-3,6):
tabel[x] = f(x)
#afisare tabel
print(f"{'x':>5} | {'f(x)':>6}")
print("-" * 15)
for x, val in tabel.items():
print(f"{x:>5} | {val:>6}")
radacini = [x for x,val in tabel.items() if val == 0]
print(f"\nRadacini in [-3,5]: {radacini}")
python/laborator/lab5.py
+110
View File
@@ -0,0 +1,110 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 20 14:18:48 2026
@author: alex
"""
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
rez = a[a>5]
print(rez)
a = np.zeros(7)
b = np.ones(5)
c = np.arange(0,15,2)
print(a, b, c)
d = np.linspace(-2, 2, 9)
print(d)
print(len(d))
f = np.arange(-5,6,1)
print(f)
x = np.array([-3,-2,-1,0,1,2,3])
print(x+2)
print(3*x -1)
print(x**2)
print(x**2 + 3*x +2)
print(np.abs(x))
print(abs(x))
y = np.array([0,1,2,3,4,5])
print(y*y + 3)
y_1 = y.tolist()
print([i**2 + 3 for i in y_1])
a = np.array([4,7,2,9,6,2,9])
print(np.sum(a))
print(np.mean(a))
print(f"minimul este {min(a)} la pozitia {np.argmax(a)}; maximul este {max(b)} la pozitia {np.argmin(a)}")
print(np.where(a == np.min(a)))
print(np.where(a == np.max(a)))
print(np.sort(a))
a = np.array([-4,-1,0,2,5,7,8,11])
print(a[a>0])
print(a[a%2 == 0])
print(a[(a >= 0) & (a <= 7)])
print(a[a > np.mean(a)])
c = np.array([12,15,18,21,24,19,16])
f = c *(9/5) + 32
print(f)
print(np.mean(c))
print(np.argmax(c))
print(c - np.mean(c))
print(c[c > np.mean(c)])
def distanta_fata_de_medie(a):
return np.abs((a-np.mean(a)))
a = np.arange(-100,1,10)
print(a)
print(distanta_fata_de_medie(a))
def raport_fata_de_max(a):
if np.max(a) == 0:
return None
else:
return(a / np.max(a))
print(a)
print(raport_fata_de_max(a))
a = np.arange(0,101,10)
print(a)
print(raport_fata_de_max(a))
a = np.arange(1,25,3)
def normalizare_0_1(a):
if np.max(a) == np.min(a):
return a*0
else:
return((a-np.min(a))/(np.max(a)-np.min(a)))
print(a)
print(normalizare_0_1(a))
a = np.zeros(20)
print(normalizare_0_1(a))
def este_sortat_crescator(a):
b = np.sort(a)
if np.array_equal(a,b):
print("Sirul este sortat")
else:
print("Sirul nu este sortat")
ns = np.array([1,200,3,4,22,19])
este_sortat_crescator(ns)
s = np.arange(1,10)
este_sortat_crescator(s)