sábado, 12 de outubro de 2013

Devagar se vai ao longe

O módulo turtle é um velho conhecido nosso. Permite fazer desenhos e gráficos. Vamos supor que queríamos reproduzir o sinal de local perigoso devido a radioactividade.
Vamos transformar esta questão em mais um exercício para exemplificar como se pode dominar a complexidade. Primeiro, dividimos o problema em dois sub-problemas: (1) desenhar o fundo (um quadrado amarelo com um bordo espesso) e (2) ... desenhar o resto.
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade():
    # Desenha fundo
    fundo()
    # Desenha frente
    frente()

def fundo():
    pass

def frente():
    pass
    
if __name__ == '__main__':
    radioactividade()
    turtle.exitonclick()
Pode parecer estranho, mas este programa já pode ser executado, embora não faça (quase) nada. Com este modelo fica claro que apenas tomámos a decisão de dividir o problema em dois. Nada mais. Tentemos resolver agora a primeira questão. Sabemos desenhar quadrados em função do comprimento do lado.
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(lado):
    # Desenha fundo
    fundo(lado)
    # Desenha frente
    frente()

def fundo(lado):
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.hideturtle()

def frente():
    pass
    
if __name__ == '__main__':
    radioactividade(100)
    turtle.exitonclick()
Ao concretizar introduzimos uma variável (lado) que terá que ser argumento do programa principal (radioactividade) e do fundo.Vamos completar a especificação tornando possível definir a cor e a espessura do bordo (não nos vamos preocupar para já nem com o posicionamento do quadrado nem com a orientação.)
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(lado):
    # Desenha fundo
    fundo(lado,'yellow',4)
    # Desenha frente
    frente()

def fundo(lado, cor, espessura):
    # Atributos
    turtle.width(espessura)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def frente():
    pass
    
if __name__ == '__main__':
    radioactividade(100)
    turtle.exitonclick()
A solução acima cumpre a primeira parte. Se mandarmos correr o programa o que aparece é:
Notemos de passagem que a função fundo permite desenhar um fundo quadrado com qualquer cor e qualquer espessura. No entanto, preferimos não tornar essas opções possíveis no nosso problema inicial pelo que a cor e a espessura não são parâmetros da função radioactividade. Agora é a vez do segundo sub-problema. Vamos basear-nos no princípio ilustrado em post anterior: olhar e ver! E vemos a existência de um sector circular repetido três vezes e de uma circunferência. Daí que...
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(lado):
    # Desenha fundo
    fundo(lado,'yellow',4)
    # Desenha frente
    frente()

def fundo(lado, cor, espessura):
    # Atributos
    turtle.width(espessura)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def frente():
    # Sectores
    sector()
    sector()
    sector()
    # Circunferência
    circunferencia()

def sector():
    pass

def circunferencia():
    pass

    
if __name__ == '__main__':
    radioactividade(100)
    turtle.exitonclick()
É claro que não avançámos muito pois estão ainda muitas coisas por decidir: posição, orientação,cor de fundo, amplitude e raio dos sectores, e também a posição, cor de fundo, espessura do bordo, cor do bordo e raio da circunferência. Vamos tratar dessas questões mas, para variar, vamos começar pela circunferência. Como se vai ver vamos ter que fazer ligeiras alterações no código anterior, uma vez mais determinado pelo facto de que os sub-problemas não são independentes. Em particular, o posicionamento da circunferência depende do posicionamento do fundo. Vamos então generalizar, incluindo a posição como argumento do problema.
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(posx, posy,lado):
    # Desenha fundo
    fundo(posx, posy,lado,'yellow',4)
    # Desenha frente
    frente(lado)

def fundo(lado, cor, espessura):
    # Atributos
    turtle.width(espessura)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def frente(posx, posy, lado):
    # Sectores
    sector()
    sector()
    sector()
    # Circunferência
    circunferencia(posx+lado/2,t posy+(lado/2) - (lado/10), lado/10, 'black','yellow',2)

def sector():
    pass

def circunferencia(posx,posy,raio,cor_fundo,cor_bordo, espessura):
    # Posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Define atributos
    turtle.pencolor(cor_bordo)
    turtle.fillcolor(cor_fundo)
    turtle.width(espessura)
    # Desenha
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()

    
if __name__ == '__main__':
    radioactividade(400)
    turtle.exitonclick()
Para além do que já foi referido tivemos que ter em atenção aspectos como o facto de o raio ter Devemos também ter em conta que, se queremos o centro da circunferência no ponto (x,y), temos que ter a tartaruga afastada dessa posição, numa das coordenadas, de um valor igual ao raio. Qual das coordenadas e como afastamos depende da orientação da tartaruga. Do ponto de vista da tartaruga o centro está sempre à sua esquerda! Executemos para ver, um pouco como São Tomé.
Nada mau. Já faltou mais... Chegou a vez dos sectores. Aqui se queremos ter uma única definição que possa ser aplicada aos três sectores a única diferença significativa será a orientação. Claro que uma vez mais temos que pensar no valor da posição, do raio, da amplitude e da cor de fundo. Embora sejam os mesmos nos três casos, vamos implementar uma solução geral que possa eventualmente ser usada noutro tipo de problemas ( se pensar bem vai ver que encontra uma outra aplicação para o código geral ...).Vejamos então a nossa solução.
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(posx,posy,lado):
    # Desenha fundo
    fundo(posx, posy,lado,'yellow',4)
    # Desenha frente
    frente(posx,posy,lado)

def fundo(posx,posy,lado, cor, espessura):
    # Define posicao
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Atributos
    turtle.width(espessura)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def frente(posx,posy,lado):
    # Sectores
    sector(posx+lado/2,posy+lado/2,0,0.4*lado,60,'black')
    sector(posx+lado/2,posy+lado/2,120,0.4*lado,60,'black')
    sector(posx+lado/2,posy+lado/2,240,0.4*lado,60,'black')
    # Circunferência
    circunferencia(posx+lado/2,posy+(lado/2) - (lado/10), lado/10, 'black','yellow',2)

def sector(posx,posy,orientacao,raio, angulo, cor_fundo):
    # Atributos
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.fillcolor(cor_fundo)
    turtle.begin_fill()
    # Desenha
    turtle.forward(raio)
    turtle.left(90)
    turtle.circle(raio, angulo)
    turtle.left(90)
    turtle.forward(raio)
    turtle.left(180-angulo)
    turtle.end_fill()
    turtle.hideturtle()

def circunferencia(posx,posy,raio,cor_fundo,cor_bordo, espessura):
    # Posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Define atributos
    turtle.pencolor(cor_bordo)
    turtle.fillcolor(cor_fundo)
    turtle.width(espessura)
    # Desenha
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

    
if __name__ == '__main__':
    radioactividade(-100,-100,400)
    turtle.exitonclick()
Como se vê na solução apresentada, os sectores estão centrados e têm um raio de tamanho igual a 10% do lado. No entanto se executarmos este código verificamos que agora a circunferência não está bem posicionada. A razão está no facto de os problemas sector e circunferência ... não serem independentes. O desenho dos sectores altera a orientação final da tartaruga! A solução mais simples e cómoda é tornar a orientação um parâmetro da circunferência.
"""Devagar se vai ao longe: radioactividade."""
import turtle

def radioactividade(posx,posy,lado):
    # Desenha fundo
    fundo(posx, posy,lado,'yellow',4)
    # Desenha frente
    frente(posx,posy,lado)

def fundo(posx,posy,lado, cor, espessura):
    # Define posicao
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Atributos
    turtle.width(espessura)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def frente(posx,posy,lado):
    # Sectores
    sector(posx+lado/2,posy+lado/2,0,0.4*lado,60,'black')
    sector(posx+lado/2,posy+lado/2,120,0.4*lado,60,'black')
    sector(posx+lado/2,posy+lado/2,240,0.4*lado,60,'black')
    # Circunferência
    circunferencia(posx+lado/2,posy+(lado/2) - (lado/10), 0, lado/10, 'black','yellow',2)

def sector(posx,posy,orientacao,raio, angulo, cor_fundo):
    # Atributos
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.fillcolor(cor_fundo)
    turtle.begin_fill()
    # Desenha
    turtle.forward(raio)
    turtle.left(90)
    turtle.circle(raio, angulo)
    turtle.left(90)
    turtle.forward(raio)
    turtle.left(180-angulo)
    turtle.end_fill()
    turtle.hideturtle()

def circunferencia(posx,posy,orientacao,raio,cor_fundo,cor_bordo, espessura):
    # Posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Define atributos
    turtle.setheading(orientacao)
    turtle.pencolor(cor_bordo)
    turtle.fillcolor(cor_fundo)
    turtle.width(espessura)
    # Desenha
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

    
if __name__ == '__main__':
    radioactividade(-100,-100,400)
    turtle.exitonclick()
E agora, já está. Como vê devagar se vai ao longe.
Esta solução final resulta da nossa preguiça. E também claro, de uma análise apressada do problema. Deixamos ao leitor a tarefa de tornar a orientação do desenho um parâmetro do problema. Se quiser ainda pode alterar o código de modo que as cores do preenchimento possam ser outras. Deste modo pode inventar uma simbologia diferente.

sexta-feira, 11 de outubro de 2013

Programar é ... recordar!

Depois de muitos anos a programar todos nós temos um conjunto de soluções para diferentes problemas. quando se nos depara um novo problema um reflexo natural é perguntar: já resolvi este problema? Já resolvi um problema parecido? Já resolvi um problema que não sendo parecido me pode inspirar no modo de resolver o problema novo? Para tornar as coisas mais concretas olhemos para a figura seguinte:
Cinco quadrados concêntricos, coloridos. O problema é o de desenvolver um programa que crie este desenho. Depois de pensar um pouco, recordo-me do problema do logotipo dos jogos olímpicos:
Qual é analogia? O mesmo objecto repetido cinco vezes, mas com cores, posição e dimensão diferentes. Então é tentador seguir a mesma abordagem que neste caso: primeiro um programa que desenha um quadrado colorido, numa dada posição e com um dado comprimento para o lado. Como no caso anterior podia resolver este problema por partes: primeiro, um quadrado com um dado lado, depois numa dada posição e, finalmente com uma dada cor. Acho que não me levarão a mal se eu colocar já a versão final. Afinal, é o que nos vai acontecer à medida que estamos à vontade com a programação!
def quadrado_cor(posx,posy,lado, cor):
    # Posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # Define cor
    turtle.pencolor(cor)
    # Desenha
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.hideturtle()
Agora a segunda parte: desenhar cinco, variando a posição, o lado e a cor. Vamos fazer um desenho para nos ajudar, desenho esse que mostre a relação entre dois quadrados em função da diferença de tamanho dos respectivos lados (que designamos por incremento):
A partir do desenho não é difícil o que temos que mudar na posição e no tamanho. Na posição, e tomando como referência o canto inferior esquerdo a posição do quadrado externo relativamente ao interno será:

posx_ext = posx_int - incremento / 2
posy_ext = posy_int - incremento / 2

Quanto ao tamanho:
lado_ext = lado_int + incremento
Resolvida esta questão vamos então resolver o que falta.
def quadrados_concentricos(posx, posy,lado,incremento):
    quadrado_cor(posx,posy,lado,'red')
    quadrado_cor(posx - incremento/2,posy - incremento/2,lado + incremento,'green')
    quadrado_cor(posx - incremento,posy -incremento,lado + 2*incremento,'blue')
    quadrado_cor(posx - 3*incremento/2,posy-3*incremento/2,lado + 3*incremento,'black')
    quadrado_cor(posx - 2 * incremento,posy- 2*incremento,lado + 4*incremento,'orange')
    
        
        
if __name__ == '__main__':
    quadrados_concentricos(0,0,50,20)
    turtle.exitonclick()
Antes de ir fazer outra coisa volte ao código do logotipo dos jogos olímpicos e veja as semelhanças...

Olhar ... e ver

Dominar a complexidade é uma das questões mais importantes na resolução informática de problemas. Existem diferentes maneiras de o fazer, isto é, de reduzir a dificuldade em resolver um problema, como por exemplo começar por resolver uma versão mais simples do problema, esquecendo alguns detalhes da especificação e depois completar a solução adicionando o que falta, ou decompondo o problema em sub-problemas mais simples que são resolvidos separadamente, ficando para uma segunda fase agrupar as soluções parciais na solução desejada. Vamos exemplificar retomando o exemplo do desenho do logotipo dos jogos olímpicos.
Olhando para o desenho o que vemos? Cinco circunferências, com o mesmo raio, a mesma espessura do traço, mas cores e posições diferentes. A pergunta que devemos fazer é: se eu souber desenhar uma circunferência com um dado raio, espessura, cor e posição tenho a vida facilitada para desenhar as cinco? Claramente. Vamos então meter mãos à obra, resolvendo o problema de um modo geral para podermos posteriormente usar para as cinco situações diferentes. Podemos começar por esquecer vários dos atributos que devemos considerar e pensar apenas em desenhar uma circunferência com um dado raio. Simples, certo?
def circunferência(raio):
 turtle.circle(raio)
Acrescentemos agora a posição.
def circunferência(posx, posy,raio):
 # Posição
    turtle.penup()
     turtle.goto(posx, posy)
     turtle.pendown()
 # Desenha
 turtle.circle(raio)
Procedendo de igual modo para os outros atributos chegamos à versão final completa.
def circunferencia(posx, posy, cor, raio, espessura):
    # Define atributos
    turtle.penup()
    turtle.goto(posx, posy)
    turtle.pendown()
    turtle.pencolor(cor)
    turtle.width(espessura)
    # Desenha e Esconde tartaruga
    turtle.circle(raio)
    turtle.hideturtle()
Este programa permite desenhar uma circunferência podendo ser controladas a posição, o raio, a cor e a espessura. Fica por fazer dispor cinco circunferências em posições precisas. A figura que se segue ajuda-nos nos cálculos.
Assim se a posição da circunferência central da linha de cima for (x,y) as coordenadas das restantes são:

cima, à direita: (x+ 2*raio + delta, y)
cima, à esquerda: (x - 2*raio - delta,y)
baixo, à direita: (x + raio + delta/2, y - raio)
baixo, à esquerda: (x - raio - delta/2, y - raio)

Daí a parte que falta para a solução:
def olimpo(x,y,raio, espessura, delta):
    circunferencia(x,y, 'black', raio, espessura)
    circunferencia(x+2*raio+ delta, y, 'red', raio, espessura)
    circunferencia(x-2*raio-delta, y, 'blue', raio, espessura)
    circunferencia(x+raio+(delta/2), y-raio, 'green', raio, espessura)
    circunferencia(x-raio-delta/2, y-raio, 'yellow', raio, espessura)
    
   
if __name__ == '__main__':
    aneis(0,0,50, 3, 5)
    turtle.exitonclick()

quinta-feira, 10 de outubro de 2013

Do que falamos quando falamos de ....

Todos nos lembramos dos tempos idos da infância em que aprendemos a tabuada cantando-a. Hoje fazemos contas usando a tabuada mecanicamente sem grande esforço.  Claro que sabermos que contas temos de fazer continua a ser um desafio.

Aprender a programar envolve também um lado de repetição até interiorizarmos algo que passamos depois a usar de modo imediato. Também aqui fica muito por fazer, seguramente o mais difícil, mas já é um avanço ter algumas partes resolvidas.

Toda esta conversa vem a propósito da aula de hoje em que verifiquei a grande dificuldade conceptual em arrancar com a proposta de solução. Vamos então à mecanização. Sempre que vos aparecer um enunciado que diz: “Escreva/desenvolva um programa que dado isto devolve aquilo” devem ser capazes de saber que o código será algo como:
def isto_em_aquilo(isto):
 # transforma isto em aquilo
 return aquilo
ou uma sua variante, como por exemplo:
def isto_em_aquilo():
 isto = input(‘O que é isto?’)
 # Transforma isto em aquilo
 print(aquilo)
Claro que se quiser pode cantar enquanto escreve o código!

sexta-feira, 4 de outubro de 2013

Tartarugas e Geometria

Durante as aulas vimos como podíamos usar o módulo turtle para desenhar polígonos regulares. Em particular partimos das soluções para triângulos, quadrados e pentágonos:
import turtle

def  quadrado(lado):
    """ Desenha um quadrado de lado."""
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
        
        
def  triangulo(lado):
    """ Desenha um triangulo de lado."""
    for i in range(3):
        turtle.forward(lado)
        turtle.left(120)
        
def  pentagono(lado):
    """ Desenha um pentagono de lado."""
    for i in range(5):
        turtle.forward(lado)
        turtle.left(72)
e ao analisar o código para cada caso verificamos que todos têm em comum o facto de o produto do número de lados pelo ângulo de viragem ser sempre igual a 360. E terá que ser sempre assim para um polígono regular! Então podemos generalizar a nossa solução:

def  poligono(lado, num_lados):
    """ Desenha um poligono de num_lados ."""
    for i in range(num_lados):
        turtle.forward(lado)
        turtle.left(360/num_lados)



 Com este programa podemos desenhar qualquer polígono regular. Podemos pensar agora em alterar a solução geral desfazendo a relação entre o número de lados, o ângulo de viragem e 360 graus. Isso envolve considerar o ângulo como um parâmetro adicional da definição:

def  formas(lado, num_lados, angulo):
    """ Desenha sequências de segmentos eventualmente produzindo formas fechadas."""
    for i in range(num_lados):
        turtle.forward(lado)
        turtle.left(angulo)

Testando diferentes configurações verificamos que para algumas de novo obtemos formas fechadas. Alguns exemplos.
formas(100,5,144)
formas(100,8,135)
formas(100,10,108)






A razão para obtermos estas formas é simples: o produto do número de lados pelo ângulo de viragem é um múltiplo de 360!
Pode-se provar um teorema geral para qualquer forma fechada, seja polígono ou não: a soma dos ângulos de viragem ao longo da forma é sempre um múltiplo de 360. Será que o inverso é verdadeiro, ou seja, se a soma do ângulo de viragem for múltiplo de 360 graus então a forma é fechada? De um modo geral isto não é verdadeiro, embora seja verdadeiro para o caso das formas geradas pelo nosso programa formas.

Regresso ao Futuro

Depois de um ano sem dar aulas, eis-me de volta a este blogue de suporte da disciplina Introdução à Programação e Resolução de Problemas, do primeiro ano da Licenciatura em Engenharia Informática,  da Universidade de Coimbra. Vou procurar continuar a colocar aqui soluções de exemplos das aulas/testes/exames e responder às questões que queiram colocar.

O blogue será tanto mais activo quanto mais receber questões do vosso lado...

quarta-feira, 25 de janeiro de 2012

Exame Época Normal

Pergunta 2

Solução: Uma solução possível, a mais natural, seria:


for i in range(20,-1,-2):
print "i= ",i

Notar como tudo se resolve usando range com três argumentos. Note-se que os valores têm que ser impressos por ordem decrescente, incluindo o zero. Como o último argumento não conta temos que deixar ir até -1.

Pergunta 3
Enunciado: Suponha que participa numa competição em que lhe são atribuídos pontos (um número inteiro) por cada jogo que faz. Admita também que a sua pon- tuação final é a média dos pontos que obteve nos jogos, depois de serem retirados o seu melhor e o pior resultados. Escreva um programa que dados os resultados dos vários jogos, devolve a sua pontuação.

Solução: Sabemos que as pontuaçõeds estão guardadas numa lista e que temos que primeiro retirar o valor menor e o valor maior. Podemos para tal, usar as funções max e min. Mas vamos fazer de outro modo, começando por ordenar a lista. Depois disso, basta fazer uma cópia sem o primeiro (o mais pequeno) e o último (o maior) elementos. O cálculo da média depois é trivial, havendo apenas o cuidado de garantir que a divisão envolve floats. Atente-se ainda o modo como podemos somar os elementos de uma lista com a função sum.


def pontos(valores):
valores.sort()
contam = valores[1:-1]
res = sum(contam)/float(len(contam))
return res

Pergunta 4


Enunciado: Suponha um ficheiro formado por várias linhas e em que cada linha contém um certo número de números. A quantidade de números por linha não é necessariamente a mesma. Um exemplo de ficheiro possível ( mas é apenas um exemplo!):

12 15 30 26
100 34 13
34
58 39 9 22

Pretendemos um programa que dado um ficheiro com estas caracterís- ticas, determina o valor mais alto em cada linha, e calcula a média desses valores. Se olharmos para o exemplo acima o resultado devia ser calculado a como (30 + 100 + 34 + 58)/4, ou seja, 55.5.

Solução: Uma vez mais procuraremos uma solução simples. Precisamos de ler e guardar os dados. Fazemos isso, construindo uma lista de cadeias de caracteres (readlines()). Mas o que queremos é manipular números. por isso, a seguir, obtemos os dados na forma de lista de listas, em que cada elemento é uma listqa com os números de uma dada linha. Para isso, recorremos a listas por compreensão, embora também possa ser feito de modo mais convencional com um ciclo for. Vamos depois identificar os maiores valores em cada linha, recorrendo à função max e a listas por compreensão. Obtido estes valores o cálculo da média é trivial.

def media(ficheiro):
# ler dados
f_in = open(ficheiro,'r')
dados = f_in.readlines()
f_in.close()
# passa a lista de lista de números
for i in range(len(dados)):
dados[i] = [float(elem) for elem in dados[i][:-1].split()]
# identifica os máximos
maximos = [max(elem) for elem in dados]
# calcula média
media = sum(maximos) / float(len(maximos))
return media

Pergunta 5

Enunciado: Uma matriz de inteiros pode ser representada em Python por uma lista de listas. Assim, por exemplo, a matriz:

5 0 0
9 0 8
0 0 33

pode ser representada por:
[[5,0,0], [9,0,8],[0,0,33]]
Quando uma matriz tem muitos valores iguais a zero, uma forma mais conveniente de representar essa matriz usando apenas os valores não nulos. Uma forma de fazer isso em Python é através de um dicionário, em que cada elemento da matriz aij = k, k ̸= 0 é representada pelo par (chave:valor) ( (i, j):k). No caso anterior teríamos:
{ (1,1):5, (2,1):9, (2,3): 8, (3,3):33}

Escreva um programa que dada uma matriz representada por uma lista de listas, devolva a matriz equivalente representada por um dicionário.

Solução: Precisamos converter os dados da matriz, inicialmente organizados como uma lista de listas, para um dicionário, onde apenas colocamos os elementos diferentes de zero. A ideia da solução mais abaixo é percorrer a matriz elemento a elemento e testar se o valor é diferente de zero. Se for guardamos no dicionário.



def esparsa(matriz):
res = {}
for linha in range(len(matriz)):
for coluna in range(len(matriz[0])):
if matriz[linha][coluna] != 0:
res[(linha+1,coluna+1)] = matriz[linha][coluna]
return res