DEV Community: Jardson Yan Silva dos Santos

LABORATORIO DE PROGRAMAÇÃO

Jardson Yan Silva dos Santos — Tue, 09 Apr 2024 19:18:59 +0000

AULA VI

class No:
    def __init__(self, valor):
        self.valor = valor
        self.anterior = None
        self.proximo = None

class DuplamenteEncadeada:
    def __init__(self):
        self.primeiro = None
        self.proximo = None

    def vazia(self):
        return self.primeiro is None

    def inserir_no_inicio(self, valor):
        new_node = No(valor)
        if self.vazia():
            self.primeiro = new_node
            self.ultimo = new_node
        else:
            new_node.proximo = self.primeiro
            self.primeiro.anterior = new_node
            self.primeiro = new_node

    def inserir_no_final(self, valor):
        new_node = No(valor)
        if self.vazia():
            self.primeiro = new_node
            self.ultimo = new_node
        else:
            new_node.anterior = self.ultimo
            self.ultimo.proximo = new_node
            self.ultimo = new_node

    def remover_do_inicio(self):
        if self.vazia():
            return None
        valor_removido = self.primeiro.valor
        if self.primeiro == self.ultimo:
            self.primeiro = None
            self.ultimo = None
        else:
            self.primeiro = self.primeiro.proximo
            self.primeiro.anterior = None
        return valor_removido

    def remover_do_final(self):
        if self.vazia():
            return None
        valor_removido = self.ultimo.valor
        if self.ultimo == self.primeiro:
            self.primeiro = None
            self.ultimo = None
        else:
            self.ultimo = self.ultimo.anterior
            self.ultimo.proximo = None
        return valor_removido

    def imprimir(self):
        no_atual = self.primeiro
        while no_atual is not None:
            print(no_atual.valor, end=" ")
            no_atual = no_atual.proximo
        print()

lista = DuplamenteEncadeada()

lista.inserir_no_inicio(90)
lista.inserir_no_inicio(50)
lista.inserir_no_final(33)
lista.inserir_no_final(80)
lista.inserir_no_final(60)

lista.imprimir()

lista.remover_do_inicio()
lista.remover_do_final()

lista.imprimir()

Explicação: Esse código cria duas classes: No, que representa um nó de uma lista duplamente encadeada, e DuplamenteEncadeada, que implementa uma lista duplamente encadeada.

Quando o código é executado, uma lista duplamente encadeada é criada e inicializada como vazia. Em seguida, são adicionados elementos à lista usando os métodos inserir_no_inicio e inserir_no_final.

Depois de adicionar os elementos, a lista é impressa para mostrar seu conteúdo.

Em seguida, dois elementos são removidos da lista, um do início e outro do final, usando os métodos remover_do_inicio e remover_do_final, respectivamente.

Por fim, a lista é impressa novamente para mostrar seu conteúdo após as remoções.

No geral, o código cria e manipula uma lista duplamente encadeada, adicionando elementos no início e no final, removendo elementos do início e do final, e imprimindo a lista em diferentes estágios.

Link para rodar: https://onlinegdb.com/X_DCWrxLx

AULA VII

# transforma a primeira letra de uma string em maiúscula
def upper(string):
    return string[0].upper() + string[1:]

# conta quantas vogais existem em uma determinada string
def count(string):
    vogais = 'aeiou'
    return sum(letra in vogais for letra in string.lower())

string = "laboratório"
string_upper = upper(string)

string = "laboratório"
string_count = count(string)

print(string_upper)
print(string_count)

Explicação: Este código define duas funções: upper, que transforma a primeira letra de uma string em maiúscula, e count, que conta quantas vogais existem em uma determinada string. Em seguida, a string "laboratório" é processada por ambas as funções e os resultados são impressos.

Link para rodar: https://onlinegdb.com/R36gjfW2w

AULA IX

from collections import Counter
import matplotlib.pyplot as plt

def ocorrencias(dado):
    return Counter(dado)

def calcular_frequencia(contador_dado):
    total = sum(contador_dado.values())
    return [count / total for count in contador_dado.values()]

def criar_bins(dado, num_bins):
    min_valor = min(dado)
    max_valor = max(dado)
    bin_width = (max_valor - min_valor) / num_bins
    return [min_valor + i * bin_width for i in range(num_bins + 1)]

def plot_histogram(dado, title='Idades de um grupo', xlabel='Idade', ylabel='Frequencia absoluta', bins=5, rwidth=0.9):
    data_counts = ocorrencias(dado)

    frequecias = calcular_frequencia(data_counts)

    bins = criar_bins(dado, bins)

    plt.title('Idades de um grupo', fontsize=30)
    plt.xlabel('Idade')
    plt.ylabel('Frequencia absoluta')
    plt.hist(idades, 5, rwidth=0.9)
    plt.savefig('grafico.png')
    plt.show


idades=[65,26,67,50,47,73,1,58,2,94,12,22,12,95,25,13,61,41,24,95,
        3,71,53,24,23,44,83,30,19,32,71,66,45,6,99,4,76,27,50,18,58,
        61,53,72,14,78,36,89,6,71,58,69,22,34,38,51,71,83,22,22,36,44,
        16,58,20,49,28,55,21,26,23,41,21,95,18,63,55,2,61,81,39,20,39,
        17,66,60,73,26,54,16,76,83,9,12,15,35,54,11,7,61]

plot_histogram(idades)

Explicação: Este código cria um histograma das idades de um grupo usando a biblioteca matplotlib. Ele define funções para calcular as ocorrências dos dados, calcular a frequência relativa, criar bins para o histograma e plotar o histograma.

LABORATÓRIO DE PROGRAMAÇÃO

Jardson Yan Silva dos Santos — Wed, 20 Mar 2024 01:21:21 +0000

AULA II

frase = 'o rato roeu a roupa do rei de roma'
antiga = 'rato'
nova = 'gato'
novo_texto = frase.replace(antiga, nova)
print(novo_texto)

Explicação: Este código é escrito em Python, uma linguagem de programação de alto nível.

Ele basicamente faz uma substituição de uma palavra em uma frase. Primeiro, define uma frase, uma palavra antiga que será substituída e uma palavra nova que substituirá a antiga. Em seguida, utiliza o método replace() para fazer a substituição e imprime o resultado.

Link para rodar: https://onlinegdb.com/4sNKnr2an

AULA III

PARTE 1:

# Função que retorna o máximo dos valores determinados (value1 e value2).

def numMax(value1, value2):
    numeros = value1, value2
    print(numeros)
    return max(numeros)

numero1 = 484
numero2 = 387

print(numMax(numero1, numero2))

Explicação: Este código é em Python, uma linguagem de programação de alto nível.

Ele define uma função chamada numMax que recebe dois valores como argumentos (value1 e value2). Dentro da função, cria uma tupla chamada numeros contendo os valores recebidos como argumentos, imprime essa tupla e retorna o valor máximo entre os dois números usando a função embutida max().

Em seguida, define duas variáveis numero1 e numero2 com valores específicos.

Depois, chama a função numMax passando as variáveis numero1 e numero2 como argumentos e imprime o resultado.

Em resumo, esse código define uma função que retorna o máximo entre dois valores e demonstra seu uso passando dois números como entrada.

Link para rodar: https://onlinegdb.com/6VHYtkBSZY

PARTE 2:

# Retorna -1 se o valor é menor que 0, 0 se o valor é 0, 1 se o valor é maior que 0.

def valor_absoluto(numero):

  if numero < 0:
    return -1
  elif numero == 0:
    return 0
  else:
    return 1

numero0 = 0

numero1 = 5

numero2 = -5

resultado = valor_absoluto(numero0)
resultado1 = valor_absoluto(numero1)
resultado2 = valor_absoluto(numero2)

print(f"{numero0} é {resultado}")
print(f"{numero1} é {resultado1}")
print(f"{numero2} é {resultado2}")

Explicando: Este código é em Python e define uma função chamada valor_absoluto que retorna:

-1 se o número é menor que 0,
0 se o número é igual a 0, e
1 se o número é maior que 0.

Ele usa condicionais (if, elif, else) para determinar o valor retornado com base no valor do número passado como argumento para a função.

Em seguida, são definidos três números (numero0, numero1 e numero2) com valores específicos.

Depois, chama a função valor_absoluto para cada um desses números e armazena os resultados nas variáveis resultado, resultado1 e resultado2.

Por fim, imprime os números e os resultados correspondentes.

Resumidamente, esse código determina se um número é negativo, zero ou positivo e imprime o resultado.

Link para rodar: https://onlinegdb.com/4ChIDyFGA

AULA IV
PARTE 1:

import pygame
import sys

pygame.init()

size = width, height = 320, 240

window = pygame.display.set_mode((600, 500))

black = 0, 0, 0
white = 255, 255, 255

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(black)

    pygame.draw.circle(window, (255, 0, 0), [200, 200], 50, 3)

    pygame.draw.circle(window, (255, 0, 0), [400, 200], 50, 0)

    pygame.display.flip()import pygame
import sys

pygame.init()

size = width, height = 320, 240

window = pygame.display.set_mode((600, 500))

black = 0, 0, 0
white = 255, 255, 255

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(black)

    pygame.draw.circle(window, (255, 0, 0), [200, 200], 50, 3)

    pygame.draw.circle(window, (255, 0, 0), [400, 200], 50, 0)

    pygame.display.flip()

Explicando: Este código em Python usa a biblioteca Pygame para criar uma janela gráfica exibindo dois círculos vermelhos.

Ele define o tamanho da janela, as cores preta e branca, e entra em um loop infinito que executa continuamente.

Dentro do loop, verifica se algum evento do Pygame ocorreu, como o fechamento da janela. Se o evento for de fechamento da janela, o programa é encerrado.

Em seguida, preenche a janela com a cor preta, desenha um círculo vermelho com borda nas coordenadas (200, 200) e outro círculo vermelho sólido nas coordenadas (400, 200).

Finalmente, atualiza a tela para exibir as alterações feitas.

Resumidamente, este código cria uma janela gráfica com dois círculos vermelhos, um com borda e outro sólido, que são desenhados continuamente enquanto a janela estiver aberta. O programa encerra quando o usuário fecha a janela.

PARTE 2:

import pygame
import sys

pygame.init()

window = pygame.display.set_mode((600, 500))

black = 0, 0, 0
blue = (0, 0, 255)
white = 255, 255, 255

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(black)

    pygame.draw.polygon(window, blue, [(150, 300), (300, 100), (450, 300)], 0)

    pygame.display.flip()

Explicando: Este código em Python usando a biblioteca Pygame cria uma janela gráfica exibindo um triângulo azul.

Ele define a janela com tamanho de 600 pixels de largura por 500 pixels de altura, as cores preta, azul e branca, e entra em um loop infinito que executa continuamente.

Dentro do loop, verifica se algum evento do Pygame ocorreu, como o fechamento da janela. Se o evento for de fechamento da janela, o programa é encerrado.

Em seguida, preenche a janela com a cor preta, desenha um triângulo azul nas coordenadas especificadas e atualiza a tela para exibir as alterações feitas.

Resumidamente, este código cria uma janela gráfica com um triângulo azul desenhado, que é atualizado continuamente enquanto a janela estiver aberta. O programa encerra quando o usuário fecha a janela.

PARTE 3:

import pygame
import sys

pygame.init()

window = pygame.display.set_mode((600, 500))

black = 0, 0, 0
blue = (0, 0, 255)
white = 255, 255, 255

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(black)

    pygame.draw.polygon(window, blue, [(150, 350), (300, 100), (450, 350)], 2)

    pygame.display.flip()

Explicando:
Este código em Python utilizando a biblioteca Pygame cria uma janela gráfica exibindo um triângulo azul com borda.

Ele define uma janela com tamanho de 600 pixels de largura por 500 pixels de altura, além de definir as cores preta, azul e branca. Em seguida, entra em um loop infinito que executa continuamente.

Dentro do loop, o código verifica se algum evento do Pygame ocorreu, como o fechamento da janela. Se o evento for de fechamento da janela, o programa é encerrado.

Em seguida, preenche a janela com a cor preta, desenha um triângulo azul com uma borda de espessura 2 pixels nas coordenadas especificadas e atualiza a tela para exibir as alterações feitas.

Resumidamente, este código cria uma janela gráfica com um triângulo azul com borda desenhado, que é atualizado continuamente enquanto a janela estiver aberta. O programa encerra quando o usuário fecha a janela.

PARTE 4:

import pygame
import sys

pygame.init()

size = width, height = 320, 240

window = pygame.display.set_mode((600, 500))

black = 0, 0, 0
white = 255, 255, 255

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(black)

    pygame.draw.rect(window, (0,   0, 255), [100, 100, 400, 100], 0)

    pygame.draw.rect(window, (0, 0, 255), [100, 220, 400, 100], 2)


    pygame.display.flip()

Explicando: Este código em Python, utilizando a biblioteca Pygame, cria uma janela gráfica exibindo dois retângulos azuis, um sólido e outro com borda.

Ele define uma janela com tamanho de 600 pixels de largura por 500 pixels de altura, além de definir as cores preta e branca. Em seguida, entra em um loop infinito que executa continuamente.

Dentro do loop, o código verifica se algum evento do Pygame ocorreu, como o fechamento da janela. Se o evento for de fechamento da janela, o programa é encerrado.

Em seguida, preenche a janela com a cor preta, desenha um retângulo azul sólido e um retângulo azul com borda de espessura 2 pixels nas coordenadas especificadas. Depois, atualiza a tela para exibir as alterações feitas.

Resumidamente, este código cria uma janela gráfica com dois retângulos azuis, um sólido e outro com borda, que são atualizados continuamente enquanto a janela estiver aberta. O programa encerra quando o usuário fecha a janela.

PARTE 5:

import pygame
import sys

pygame.init()

window = pygame.display.set_mode((800, 500))

black = 0, 0, 0
white = 255, 255, 255

eixo_x = 300
eixo_y = 300

velocidade = 5

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()

    window.fill(white)

    pygame.draw.circle(window, (0, 0, 255), (eixo_x, eixo_y), 6)

    eixo_x += velocidade

    if eixo_x >= 600:
        velocidade = 0

    pygame.display.flip()
    pygame.time.delay(10)

Explicando: Este código em Python, utilizando a biblioteca Pygame, cria uma janela gráfica exibindo um círculo azul que se move horizontalmente até atingir uma determinada posição e depois para.

Ele define uma janela com tamanho de 800 pixels de largura por 500 pixels de altura, além de definir as cores preta e branca. Define também as variáveis eixo_x e eixo_y para controlar a posição do círculo e a variável velocidade para controlar a velocidade do movimento.

Em seguida, entra em um loop infinito que executa continuamente. Dentro do loop, o código verifica se algum evento do Pygame ocorreu, como o fechamento da janela. Se o evento for de fechamento da janela, o programa é encerrado.

Então, preenche a janela com a cor branca, desenha um círculo azul nas coordenadas especificadas e atualiza a tela para exibir as alterações feitas. A posição do círculo é atualizada aumentando o valor de eixo_x pela velocidade a cada iteração do loop.

Quando a posição eixo_x atinge ou ultrapassa o valor de 600, a velocidade é definida como 0, o que para o movimento do círculo.

Resumidamente, este código cria uma janela gráfica com um círculo azul que se move horizontalmente até atingir uma certa posição, e depois para de se mover. O programa encerra quando o usuário fecha a janela.