Defina imperativamente em Python, usando dois ciclos encaixados, uma função f
que recebe uma matriz quadrada m
e devolve um par (lmin,zdiag)
em que lmin
é a lista dos valores mínimos de cada linha da matriz, e zdiag
é True
se existe algum zero na diagonal da matriz e False
caso contrário.
Nomeadamente, f([[10,4,3],[1,5,1],[0,4,0]])
deverá ser ([3,1,0],True)
pois o mínimo da primeira linha é 3, o mínimo da segunda linha é 1, e o mínimo da terceira linha é 0, e a diagonal tem os valores 10, 5, 0.
Neste exercício não pode usar definições por compreensão nem métodos. As únicas operações sobre listas permitidas são: lista vazia ([]
), acesso aos elementos da lista por posição (lista[posição]
), seccionamento da lista (lista[posição:posição]
), concatenação (+
), comparação com a lista vazia (==[]) e cálculo do comprimento (len
).
def f(m):
lmin=[]
zdiag=False
i=0
while i<len(m):
if not(zdiag) and m[i][i]==0:
zdiag=True
vmin=m[i][0]
j=1
while j<len(m):
if m[i][j]<vmin:
vmin=m[i][j]
j=j+1
lmin=lmin+[vmin]
i=i+1
return (lmin,zdiag)
f([[10,4,3],[1,5,1],[0,4,0]])
Defina imperativamente em Python, usando dois ciclos encaixados, uma função g
que recebe uma matriz m
e devolve um par (cpos,stot)
tal que cpos
é a lista dos índices das colunas da matriz cujos valores são todos positivos, e stot
é a soma de todas as entradas da matriz.
Nomeadamente, g([[1,1,1],[1,0,2]])
deverá ser ([0, 2], 6)
pois apenas a segunda coluna (com índice 1) contém um valor não positivo (no caso, zero), e 1+1+1+1+0+2
é 6
.
Neste exercício não pode usar definições por compreensão nem métodos. As únicas operações sobre listas permitidas são: lista vazia ([]
), acesso aos elementos da lista por posição (lista[posição]
), seccionamento da lista (lista[posição:posição]
), concatenação (+
), comparação com a lista vazia (==[]) e cálculo do comprimento (len
).
def g(m):
cpos=[]
stot=0
j=0
while j<len(m[0]):
pos=True
i=0
while i<len(m):
if pos and m[i][j]<=0:
pos=False
stot=stot+m[i][j]
i=i+1
if pos:
cpos=cpos+[j]
j=j+1
return (cpos,stot)
g([[1,1,1],[1,0,2]])
Defina imperativamente em Python, usando dois ciclos encaixados, uma função h
que recebe uma matriz quadrada m
e devolve um par (somaz,mind)
tal que somaz
é a lista dos índices das colunas da matriz cuja soma é zero, e mind
é o menor valor que ocorre na diagonal da matriz.
Nomeadamente, h([[1,0,0],[4,-1,0],[-3,1,0]])
deverá ser ([1,2],-1)
pois a primeira coluna soma 1+4-3=2, mas as colunas 1 e 2 somam 0-1+1=0+0+0=0, respectivamente, e a diagonal tem os valores 1, -1, 0 cujo mínimo é -1.
Neste exercício não pode usar definições por compreensão nem métodos. As únicas operações sobre listas permitidas são: lista vazia ([]
), acesso aos elementos da lista por posição (lista[posição]
), seccionamento da lista (lista[posição:posição]
), concatenação (+
), comparação com a lista vazia (==[]) e cálculo do comprimento (len
).
def h(m):
somaz=[]
mind=m[0][0]
j=0
while j<len(m):
if m[j][j]<mind:
mind=m[j][j]
soma=0
i=0
while i<len(m):
soma=soma+m[i][j]
i=i+1
if soma==0:
somaz=somaz+[j]
j=j+1
return (somaz,mind)
h([[1,0,0],[4,-1,0],[-3,1,0]])
Defina imperativamente em Python, usando dois ciclos encaixados, uma função k
que recebe uma matriz m
e devolve uma par (lmax,nzeros)
tal que lmax
é a lista dos valores máximos de cada linha da matriz, e nzeros
é o número de entradas nulas da matriz.
Nomeadamente, k([[2,4,-5],[1,0,6]])
deverá ser ([4, 6], 1)
pois os valores máximos das linhas da matriz são 4 e 6, respectivamente, e ocorre exactamente um zero na matriz.
Neste exercício não pode usar definições por compreensão nem métodos. As únicas operações sobre listas permitidas são: lista vazia ([]
), acesso aos elementos da lista por posição (lista[posição]
), seccionamento da lista (lista[posição:posição]
), concatenação (+
), comparação com a lista vazia (==[]) e cálculo do comprimento (len
).
def k(m):
lmax=[]
nzeros=0
i=0
while i<len(m):
vmax=m[i][0]
j=0
while j<len(m[0]):
if m[i][j]==0:
nzeros=nzeros+1
if m[i][j]>vmax:
vmax=m[i][j]
j=j+1
lmax=lmax+[vmax]
i=i+1
return (lmax,nzeros)
k([[2,4,-5],[1,0,6]])