----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# importamos a biblioteca NumPy
import numpy

def main():
  # valores a serem observados
  valores = [4, 9, 12, 25]

  # vamos obter a média aritmética simples
  media = numpy.mean(valores)

  # vamos mostrar o resultado
  print("A média dos valores é:", media)

if __name__== "__main__":
  main()

Informe um valor de 0 até 999: 821
A soma dos dígitos é: 11

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# função principal do programa
def main():
  # vamos solicitar ao usuário que informe um valor inteiro
  # na faixa 0 a 999 (incluindo)
  valor = int(input("Informe um valor de 0 até 999: "))
  
  # vamos verificar se o valor está na faixa permitida
  if(valor < 0 or valor > 999):
    print("Valor fora da faixa permitida")
  else:
    # vamos obter o terceiro dígito
    terceiro = valor % 10
    # obtém os digitos restantes
    valor = valor // 10
 
    # vamos obter o segundo dígito
    segundo = valor % 10
    # obtém os digitos restantes
    valor = valor // 10
 
    # vamos obter o primeiro dígito
    primeiro = valor % 10
    # obtém os digitos restantes
    valor = valor // 10
 
    # vamos obter a soma dos dígitos
    soma = terceiro + segundo + primeiro
 
    # vamos mostrar o resultado
    print("A soma dos dígitos é:", soma)
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# função que permite calcular o MDC
def MDC(a, b):
  while(b != 0):
    resto = a % b
    a = b
    b = resto
 
  return a

# função principal do programa
def main():
  print("Este programa permite calcular o MDC\n")
  x = int(input("Informe o primeiro valor: "))
  y = int(input("Informe o segundo valor: "))
  
  print("\nO Máximo Divisor Comum de", x, "e", y, "é", MDC(x, y))
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# método que permite ordenar o vetor de inteiros
# usando a ordenação Insertion Sort
def insertionSort(vetor):
  # percorre todos os elementos do vetor começando
  # pelo segundo elemento
  for i in range(len(vetor)):
    atual = vetor[i] # o valor atual a ser inserido
    # começa a comparar com a célula à esquerda de i
    j = i - 1
      
    # enquanto vetor[j] estiver fora de ordem em relação
    # a atual
    while((j >= 0) and (vetor[j] > atual)):
      # movemos vetor[j] para a direita e decrementamos j
      vetor[j + 1] = vetor[j]
      j = j - 1
      
      # colocamos atual em seu devido lugar
      vetor[j + 1] = atual

# função principal do programa
def main():
  # cria uma lista de inteiros
  valores = [4, 6, 2, 8, 1, 9, 3, 0, 11]
  
  # exibimos o vetor na ordem original
  print("Ordem original:\n")
  for i in range(len(valores)):
    print(valores[i], end = "  ")
    
  # vamos ordenar o vetor agora
  insertionSort(valores)
    
  # exibimos o vetor ordenado
  print("\n\nOrdenado:\n")
  for i in range(len(valores)):
    print(valores[i], end = "  ")

if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

def main():
  # cria uma lista de nomes
  nomes = ['Carlos', 'Igor', 'Osmar', 'Fernanda']
 
  # exibe a lista na ordem original
  print(nomes)
  
  # ordena a lista
  nomes.sort(key = len)
 
  # exibe a lista ordenada
  print(nomes)

if __name__== "__main__":
  main()

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

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# 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()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# função principal do programa
def main():
  numero = 0
 
  while numero <= 10:
    print(numero)
    numero = numero + 1
  else:
    print("Terminei")
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# função principal do programa
def main():
  numero = 0
 
  while numero > 10:
    print(numero)
    numero = numero + 1
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# função principal do programa
def main():
  continuar = True
  valor = 0
 
  while continuar:
    print(valor)
   
    if valor > 5:
      continuar = False
    else:
      valor = valor + 1
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# vamos precisar do módulo Math
import math

# função principal do programa
def main():
  # vamos ler os valores x e y
  x = float(input("Informe o valor de x: "))
  y = float(input("Informe o valor de y: "))
     
  # o primeiro passo é calcular a norma do vetor
  norma = math.sqrt(math.pow(x, 2) + math.pow(y, 2))
    
  # agora obtemos as componentes x e y do vetor unitário
  u_x = x / norma
  u_y = y / norma
    
  # mostra o resultado
  print("O vetor unitário é: (x = {0}; y = {1})".format(u_x, u_y))
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# vamos precisar do módulo Math
import math

# função principal do programa
def main():
  # vamos ler os valores x, y e z
  x = float(input("Informe o valor de x: "))
  y = float(input("Informe o valor de y: "))
  z = float(input("Informe o valor de z: "))
     
  # o primeiro passo é calcular a norma do vetor
  norma = math.sqrt(math.pow(x, 2) + math.pow(y, 2) + math.pow(z, 2))
    
  # agora obtemos as componentes x, y e z do vetor unitário
  u_x = x / norma
  u_y = y / norma
  u_z = z / norma
    
  # mostra o resultado
  print("O vetor unitário é: (x = {0}; y = {1}; z = {2})".format(
    u_x, u_y, u_z))
  
if __name__== "__main__":
  main()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# 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

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# 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 deleta um nó no final de uma lista ligada
  # este método retorna o nó excluído
  def remover_final(self):
    # a lista está vazia?  
    if self.inicio == None:
      return None
    else:
      # vamos excluir e retornar o primeiro nó da lista
      removido = self.inicio
      
      # a lista possui apenas um nó?
      if self.inicio.get_proximo() == None:
        # a lista agora ficará vazia
        self.inicio = None
      else:
        # começamos apontando para o início da lista   
        no_atual = self.inicio
        no_anterior = self.inicio

        # enquanto o próximo do nó atual for diferente de nulo
        while no_atual.get_proximo() != None:
          # avançamos o nó anterior
          no_anterior = no_atual
          # saltamos para o próximo nó
          no_atual = no_atual.get_proximo()

        # na estamos na posição de exclusão
        removido = no_atual
        no_anterior.set_proximo(None)
    
    # retorna o nó removido
    return removido

  # 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 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()

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# 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 30 no início da lista")
  lista.inserir_inicio(30)
  print("Conteúdo da lista: ")
  lista.exibir()
  print("Insere o valor 27 no início da lista")
  lista.inserir_inicio(27)
  print("Conteúdo da lista: ")
  lista.exibir()

  print("Remove um nó no final da lista")
  removido = lista.remover_final()
  if removido == None:
    print("Não foi possível remover. Lista vazia")
  else:
    print("Nó removido:", removido.get_info())  
  print("Conteúdo da lista: ")
  lista.exibir()

if __name__== "__main__":
  main()