 |
|
Você está aqui: Python ::: Estruturas de Dados ::: Lista Ligada Simples |
Como inserir um novo nó na posição n de uma lista singularmente encadeada em PythonQuantidade de visualizações: 998 vezes |
|
Depois de aprendermos a inserir nós no início e no final de uma lista singularmente ligada (singly linked list) em Python, chegou a hora de vermos o código que insere o nó em qualquer posição da lista. Este procedimento é um pouco mais complicado, e requer muita atenção para o seu perfeito entendimento. Note que temos agora um método inserir_posicao_n() que recebe o índice (começando em 0) da posição na qual queremos inserir o novo nó e a informação que estará contida no nó. No exemplo a seguir precisamos dos métodos inserir_inicio() e inserir_final() também. Isso faz sentido. Se o índice for 0 nós inserimos o novo nó no início, e se o índice for igual ao tamanho da lista nós inserimos no final. Caso contrário nós inserimos no meio da lista. Por "meio da lista" queremos dizer qualquer posição que não seja no início ou no fim da lista encadeada. Vamos começar então com o código para a classe No da lista singularmente ligada (que salvei em um arquivo no_lista_singularmente_ligada.py): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# classe No para uma lista singularmente encadeada ou
# ligada - Singly Linked List
class No:
# construtor da classe No
def __init__(self, info, proximo):
self.info = info
self.proximo = proximo
# método que permite definir o conteúdo do nó
def set_info(self, info):
self.info = info
# método que permite obter a informação de um nó
def get_info(self):
return self.info
# método que permite definir o campo próximo deste nó
def set_proximo(self, proximo):
self.proximo = proximo
# método que permite obter o campo próximo deste nó
def get_proximo(self):
return self.proximo
# retorna True se este nó apontar para outro nó
def possui_proximo(self):
return self.proximo != None
Veja que o código para a classe Nó não possui muitas firulas. Temos apenas um campo info, que guardará o valor do nó, e um campo próximo, que aponta para o próximo nó da lista, ou null, se este for o único nó ou o último nó da lista ligada. Veja agora o código para a classe ListaLigadaSimples (lista_ligada_simples.py), com os métodos get_tamanho(), inserir_inicio(), inserir_final(), inserir_posicao_n() e exibir(): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# importa a classe No
from no_lista_singularmente_ligada import No
# classe ListaLigadaSimples
class ListaLigadaSimples:
# construtor da classe
def __init__(self):
self.inicio = None # nó inicial da lista
# método que permite inserir um novo nó no final da lista
def inserir_final(self, info):
# cria um novo nó contendo a informação e que
# não aponta para nenhum outro nó
novo_no = No(info, None)
# a lista ainda está vazia?
if self.inicio == None:
# o novo nó será o início da lista
self.inicio = novo_no
else:
# obtemos uma referência ao nó inicial da lista
no_atual = self.inicio
# enquanto o próximo nó do nó atual não for nulo
while no_atual.get_proximo() != None:
# salta para o próximo nó
no_atual = no_atual.get_proximo()
# na saída do laço nós estamos no final da lista,
# ou seja, no local adequada para a nova inserção
no_atual.set_proximo(novo_no)
# método que permite inserir um novo nó no início da lista
def inserir_inicio(self, info):
# cria um novo nó contendo a informação e que
# não aponta para nenhum outro nó
novo_no = No(info, None)
# a lista ainda está vazia?
if self.inicio == None:
# o novo nó será o início da lista
self.inicio = novo_no
else:
# o novo nó aponta para o início da lista
novo_no.set_proximo(self.inicio)
# o novo nó passa a ser o início da lista
self.inicio = novo_no
# método que permite retornar o tamanho da lista ligada, ou
# seja, a quantidade de nós na lista encadeada simples
def get_tamanho(self):
# aponta para o início da lista
no_atual = self.inicio
# ajusta o contador em 0
contador = 0
# percorre todos os nós da lista ligada
while no_atual != None:
# incrementa o contador
contador = contador + 1
# avança para o próximo nó da lista
no_atual = no_atual.get_proximo()
# retornamos a quantidade de nós
return contador
# método que permite inserir um novo nó no meio de uma lista ligada,
# ou seja, em qualquer posição da lista encadeada ou, melhor ainda,
# em uma posição n da lista
def inserir_posicao_n(self, pos, info):
# posição inválida?
if pos > self.get_tamanho() or pos < 0:
print("\nPosição inválida\n")
else:
# índice 0 indica início da lista
if pos == 0:
self.inserir_inicio(info)
else:
# índice do tamanho da lista indica inserir no final
if pos == self.get_tamanho():
self.inserir_final(info)
else:
# cria um novo nó contendo a informação e que
# não aponta para nenhum outro nó
novo_no = No(info, None)
# ajusta o contador
contador = 0
# apontamos para o início da lista
no_atual = self.inicio
# enquanto não encontrarmos a posição correta
while contador < (pos - 1):
# incrementa o contador
contador = contador + 1
# saltamos para o próximo nó
no_atual = no_atual.get_proximo()
# já estamos na posição correta
novo_no.set_proximo(no_atual.get_proximo())
no_atual.set_proximo(novo_no)
# método que permite exibir todos os nós da lista
# ligada simples (lista singularmente encadeada)
def exibir(self):
# aponta para o início da lista
no_atual = self.inicio
# enquanto o nó não for nulo
while no_atual != None:
# exibe o conteúdo do nó atual
print(no_atual.get_info())
# pula para o próximo nó
no_atual = no_atual.get_proximo()
E agora o código main() que insere alguns valores no início e no final da nossa lista singularmente encadeada e testa o método inserir_posicao_n(): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# importa a classe ListaLigadaSimples
from lista_singularmente_ligada import ListaLigadaSimples
# método principal
def main():
# cria uma nova lista encadeada simples
lista = ListaLigadaSimples()
print("Insere o valor 12 no início da lista")
lista.inserir_inicio(12)
print("Conteúdo da lista: ")
lista.exibir()
print("Insere o valor 20 no final da lista")
lista.inserir_final(20)
print("Conteúdo da lista: ")
lista.exibir()
print("Insere o valor 87 no início da lista")
lista.inserir_inicio(87)
print("Conteúdo da lista: ")
lista.exibir()
print("Insere o valor 9 no final da lista")
lista.inserir_final(9)
print("Conteúdo da lista: ")
lista.exibir()
print("Insere o valor 50 no índice 2 da lista")
lista.inserir_posicao_n(2, 50)
print("Conteúdo da lista: ")
lista.exibir()
if __name__== "__main__":
main()
Ao executar este código Python nós teremos o seguinte resultado: c:\estudos_python>python estudos.py Insere o valor 12 no início da lista Conteúdo da lista: 12 Insere o valor 20 no final da lista Conteúdo da lista: 12 20 Insere o valor 87 no início da lista Conteúdo da lista: 87 12 20 Insere o valor 9 no final da lista Conteúdo da lista: 87 12 20 9 Insere o valor 50 no índice 2 da lista Conteúdo da lista: 87 12 50 20 9 |
 Link para compartilhar na Internet ou com seus amigos: |
Python ::: Python para Engenharia ::: Geometria Analítica e Álgebra Linear |
Como converter Coordenadas Polares para Coordenadas Cartesianas usando Python - Python para EngenhariaQuantidade de visualizações: 5460 vezes |
|
Nesta nossa série de Python para Geometria Analítica e Álgebra Linear, mostrarei um código 100% funcional para fazer a conversão entre coordenadas polares e coordenadas cartesianas. Esta operação é muito frequente em computação gráfica e é parte integrante das disciplinas dos cursos de Engenharia (com maior ênfase na Engenharia Civil). Na matemática, principalmente em Geometria e Trigonometria, o Sistema de Coordenadas Polares é um sistema de coordenadas em duas dimensões no qual cada ponto no plano é determinado por sua distância a partir de um ponto de referência conhecido como raio (r) e um ângulo a partir de uma direção de referência. Este ângulo é normalmente chamado de theta (__$\theta__$). Assim, um ponto em Coordenadas Polares é conhecido por sua posição (r, __$\theta__$). Já o sistema de Coordenadas no Plano Cartesiano, ou Espaço Cartesiano, é um sistema que define cada ponto em um plano associando-o, unicamente, a um conjuntos de pontos numéricos. Dessa forma, no plano cartesiano, um ponto é representado pelas coordenadas (x, y), com o x indicando o eixo horizontal (eixo das abscissas) e o y indicando o eixo vertical (eixo das ordenadas). Quando saímos do plano (espaço 2D ou R2) para o espaço (espaço 3D ou R3), temos a inclusão do eixo z (que indica profundidade). Antes de prosseguirmos, veja uma imagem demonstrando os dois sistemas de coordenadas:  A fórmula para conversão de Coordenadas Polares para Coordenadas Cartesianas é: x = raio × coseno(__$\theta__$) y = raio × seno(__$\theta__$) E aqui está o código Python completo que recebe as coordenadas polares (r, __$\theta__$) e retorna as coordenadas cartesianas (x, y): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# importamos a biblioteca NumPy
import math as math
def main():
# vamos ler o raio e o ângulo
raio = float(input("Informe o raio: "))
theta = float(input("Informe o theta: "))
graus = input("Theta em graus (1) ou radianos (2): ")
# o theta está em graus?
if graus == "1":
theta = theta * (math.pi / 180.0)
# fazemos a conversão para coordenadas cartesianas
x = raio * math.cos(theta)
y = raio * math.sin(theta)
# exibimos o resultado
print('As Coordenadas Cartesianas são: (x = %0.2f, y = %0.2f)' %(x, y))
if __name__== "__main__":
main()
Ao executar este código nós teremos o seguinte resultado: Informe o raio: 1 Informe o theta: 1.57 Theta em graus (1) ou radianos (2): 2 As Coordenadas Cartesianas são: (x = 0.00, y = 1.00) |
Python ::: Dicas & Truques ::: Matemática e Estatística |
Como obter a série de Fibonacci recursivamente usando Python - Como calcular a sequência de Fibonacci em PythonQuantidade de visualizações: 15731 vezes |
|
Na matemática, os números de Fibonacci são uma sequência ou sucessão definida como recursiva pela fórmula: Fn = Fn - 1 + Fn - 2 Os primeiros números de Fibonacci são: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, ... Esta sequência foi descrita primeiramente por Leonardo de Pisa, também conhecido como Fibonacci, para descrever o crescimento de uma população de coelhos. Veja um techo de código que mostra como calcular e mostrar a sequência de Fibonacci de forma recursiva: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# método recursivo para calcular o Fibonacci de um
# número
def fibonacci(num):
if num < 0:
print("Não é possível obter o fibonacci de um numero negativo.")
if ((num == 0) or (num == 1)):
return num
else:
return fibonacci(num - 1) + fibonacci(num - 2)
def main():
# vamos ler a entrada do usuário
numero = int(input("Informe um inteiro: "))
# vamos obter o resultado
res = fibonacci(numero)
print("Fibonacci(%d) = %d" % (numero, res))
if __name__== "__main__":
main()
Ao executarmos este código nós teremos um resultado parecido com: Informe um inteiro: 7 Fibonacci(7) = 13 E agora saindo um pouco de Python: Leonardo Pisa (1175-1240) publicou a sequência de Fibonacci no seu livro Liber Abaci (Livro do Ábaco, em português), o qual data de 1202. Porém, comenta-se que os indianos já haviam descrito essa série antes dele. Se pegarmos um número da série de Fibonacci e o dividirmos pelo seu antecessor (por exemplo: 55 dividido por 34), teremos quase sempre o valor 1,618. Este valor é aplicado com muita frequência em análises financeiras e na informática. Leonardo Da Vinci, que chamou essa sequência de Divina Proporção, a usou para fazer desenhos perfeitos. De fato, se observarmos atentamente, perceberemos a sequência de Fibonacci também na natureza. São exemplos disso as folhas das árvores, as pétalas das rosas, os frutos, como o abacaxi, as conchas espiraladas dos caracóis ou as galáxias. |
Python ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes) |
Exercício Resolvido de Python - Escreva um programa Python que leia os elementos de um vetor A de dez elementos inteiros e construa outro vetor BQuantidade de visualizações: 275 vezes |
|
Pergunta/Tarefa: Escreva um programa Python que leia os elementos de um vetor A de dez elementos inteiros e construa outro vetor B com seus elementos distribuídos da seguinte forma: Vetor A = [8, 5, 4, 1, 2, 3, 4, 6, 9, 7] Vetor B = [24, 10, 12, 2, 6, 6, 12, 12, 27, 14] Note que os elementos do vetor B seguem um padrão. Se o elemento do vetor A estiver em uma posição par, então o elemento do vetor B será o triplo do elemento do vetor A. Caso contrário o elemento do vetor B será o dobro do elemento do vetor A. Neste exercício a primeira posição/índice dos vetores é assumida como sendo zero. Em algumas linguagens de programação o primeiro índice é um e não zero. Sua saída deverá ser parecida com: Informe o valor do 1.o elemento: 8 Informe o valor do 2.o elemento: 5 Informe o valor do 3.o elemento: 4 Informe o valor do 4.o elemento: 1 Informe o valor do 5.o elemento: 2 Informe o valor do 6.o elemento: 3 Informe o valor do 7.o elemento: 4 Informe o valor do 8.o elemento: 6 Informe o valor do 9.o elemento: 9 Informe o valor do 10.o elemento: 7 Elementos do vetor A: 8, 5, 4, 1, 2, 3, 4, 6, 9, 7 Elementos do vetor B: 24, 10, 12, 2, 6, 6, 12, 12, 27, 14 Veja a resolução comentada deste exercício em Python: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# função principal do programa
def main():
# vamos declarar e construir dois vetores de 10 inteiros
vetor_a = [0 for x in range(10)]
vetor_b = [0 for x in range(10)]
# agora vamos pedir para o usuário informar os valores
# dos elementos do vetor A
for i in range(len(vetor_a)):
vetor_a[i] = int(input("Valor do %d.o elemento: " % ((i + 1))))
# vamos construir o vetor B
for i in range(len(vetor_b)):
# o índice atual é par?
if i % 2 == 0:
vetor_b[i] = vetor_a[i] * 3
else:
vetor_b[i] = vetor_a[i] * 2
# vamos mostrar os elementos do vetor A
print("\nElementos do vetor A:\n")
for i in range(len(vetor_a)):
print("%d, " % vetor_a[i], end=' ')
# vamos mostrar os elementos do vetor B
print("\n\nElementos do vetor B:\n")
for i in range(len(vetor_b)):
print("%d, " % vetor_b[i], end=' ')
if __name__== "__main__":
main()
|
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| Equação de Bernoulli Considere o tubo de fluxo abaixo contendo óleo, que flui de forma a podermos considera-lo um fluido ideal. Ele flui por um tubo que sobe de nível e se estreita. Dois manômetros marcam a pressão em dois pontos do tubo, como mostra a figura. Qual o valor da pressão indicada no segundo manômetro? (Dados: ρóleo = 900 kg / m3 e g = 9,8 m/s2)  A) 38,4 kPa B) 162 kPa C) 64,4 kPa D) 135 kPa E) 74,0 kPa Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| Densidade de um fluido Um fluido encontra-se em um recipiente com volume de 300L. Sabendo que a massa desse fluido é de 2kg, qual a sua densidade em kg/m3? A) 0,67kg/m3. B) 6,67kg/m3. C) 0,15kg/m3. D) 150kg/m3. E) 151,5kg/m3. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Engenharia Civil - Estruturas de Aço e Madeira |
| O aço no edifício A estrutura de estabilização da moldura estrutural da edificação da figura abaixo, que se caracteriza pelo fato de não possuir amarrações diagonais nem paredes de cisalhamento para assegurar a estabilidade lateral, pode ser chamada de:  A) Estrutura contraventada. B) Moldura amarrada excentricamente. C) Moldura resistente a momentos. D) Paredes de cisalhamento. E) Nenhuma das alternativas anteriores. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em |
| Dimensionamento de pilares intermediários O projeto estrutural é conduzido por várias normas, sendo uma delas a NBR 6118 (projetos de estrutura de concreto), que define prescrições a serem obedecidas durante as etapas de dimensionamento e detalhamento de pilares com o intuito de considerar diversos fatores com influência direta nessas etapas de projeto e execução. Nos pilares, a armadura mínima é necessária para absorver esforços de flexão não considerados no dimensionamento que podem surgir na sua vida útil. No projeto das estruturas de um hotel feito de concreto armado, foram dimensionados pilares intermediários de seção retangular 30 x 30cm, com aço CA-50, para suportar uma carga vertical de cálculo de 800kN. Como parte do dimensionamento, deve-se verificar a área mínima de armadura longitudinal, cujo valor é: A) 3,6cm2. B) 2,76cm2. C) 5cm2. D) 4,2cm2. E) 2,74cm2. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| Perfil de velocidade turbulento A Lei da Parede para a determinação do perfil de velocidade empírico-turbulento envolve a determinação da velocidade de atrito na subcamada viscosa. Além do método da Lei da Parede, quais outros métodos existem para estimar o perfil de velocidade turbulento? A) Fator de atrito de Darcy, Lei da Potência e Lei Logarítmica. B) Princípio de Arquimedes, Lei da Potência e Lei do Defeito da Velocidade. C) Lei Logarítmica, Lei do Defeito da Velocidade e Lei da Potência. D) Lei da Potência, Lei de Hooke e Lei do Defeito da Velocidade. E) Fator de atrito de Darcy, Lei Logarítmica e Princípio de Arquimedes. Verificar Resposta Estudar Cards Todas as Questões |
Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Python |
Veja mais Dicas e truques de Python |
Dicas e truques de outras linguagens |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
 Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesTenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
|
1º lugar: Java |
