Programação para Redes de Computadores (técnico) (diário 2012-2)

De MediaWiki do Campus São José
Revisão de 19h30min de 26 de novembro de 2012 por Etorresini (discussão | contribs) (→‎26/11)
Ir para navegação Ir para pesquisar

Endereço encurtado: http://bit.ly/prc20122

Avaliação

São 4 avaliações, uma por mês - sem data pré-estabelecida:

  • Outubro
  • Novembro
  • Dezembro
  • Março

O conceito final da disciplina é elaborado da seguinte forma:

  • A: todas as avaliações em A.
  • B: no máximo 1 C.
  • C: no máximo 1 D, e para cada D no mínimo um B correspondente.
  • D: demais casos.

Aulas

08/10

  • Teste de conhecimento 1: instalação manual do Portugol.
  • Sobre a matéria: entendimento de do sistema computacional de Von Neumann.

Um número é primo? Em Portugol: 

inicio

// Entrada de dados
escrever "Por favor, escreva um número inteiro: "
inteiro dividendo
ler dividendo

// Processamento
inteiro divisor
inteiro divisores
inteiro resto
divisores <- 0
para divisor de (dividendo - 1) até 2 passo -1
    escrever "."
    resto <- dividendo % divisor
    se resto = 0 então
        divisores <- divisores + divisor
    fimSe
próximo
texto resposta
se divisores > 0 então
    resposta <- " não é primo."
senão
    resposta <- " é primo."
fimSe

// Saída de dados
escrever "Calculei que ", dividendo, resposta

fim

E se for perfeito? O que muda no código anterior?

15/10

  • Teste de conhecimento: Matemática básica aplicada.
  • Sobre a matéria: tipos de funções ou procedimentos de um programa.

Um triângulo é pitagórico? 

inicio

// Entrada de dados
inteiro a, b, c
escrever "Por favor, digite um número inteiro: "
ler a
escrever "Agora, outro número inteiro: "
ler b
escrever "E, por último, mais um número inteiro: "
ler c

// Processamento
inteiro a2
a2 <- potencia(a, 2)

inteiro b2c2
b2c2 <- potencia(b, 2) + potencia(c, 2)

texto resposta
se (a2 = b2c2) então
    resposta <- "é pitagórico."
senão
    resposta <- "não é pitagórico."
fimSe

// Saída de dados
escrever "O triângulo ", resposta

fim

Um número é potência de outro? 

inicio

//Entrada de dados
texto resposta
inteiro numero
escrever "Por favor, digite um número inteiro: "
ler numero

// Processamento
real raizquadrada, resto
raizquadrada <- raiz(numero)
resto <- frac(raizquadrada)
se (resto > 0) então
    resposta <- "não é potência quadrada de outro número inteiro: "
senao
    resposta <- "é potência de: "
fimSe

// Saída de dados
escrever resposta, raizquadrada
fim

Outra forma (alternativa): 

inicio

// Entrada de dados
inteiro numero
escrever "Por favor, digite um número inteiro: "
ler numero

// Processamento
texto resposta
inteiro respostaNumero
real expoente, resultado, rodada
para rodada de 2 ate 5 passo 1
    expoente <- 1 / rodada
    resultado <- potencia(numero, expoente)
    se (frac(resultado) = 0) então
        resposta <- "é potência de "
        respostaNumero <- int(resultado)
    fimSe
próximo

// Saída de dados
escrever resposta
escrever respostaNumero

fim

Desenhando uma "caixa" em volta de um número até 9999: 

inicio

// Entrada de dados
inteiro numero
escrever "Por favor, digite SEMPRE um número inteiro: "
ler numero

// Processamento
inteiro colunas, linhaembranco
colunas <- 1
se (numero > 9) então
    colunas <- 2
fimSe
se (numero > 99) então
    colunas <- 3
fimSe
se (numero > 999) então
    colunas <- 4
fimSe
se (numero > 9999) então
    colunas <- 5
fimSe
colunas <- colunas + 4
linhaembranco <- colunas - 2

// Saída de dados
inteiro coluna
para coluna de 1 ate colunas passo 1
    escrever "!"
próximo
escrever "\n"

escrever "!"
para coluna de 1 ate linhaembranco passo 1
    escrever " "
próximo
escrever "!\n"

escrever "! ", numero, " !"
escrever "\n"

escrever "!"
para coluna de 1 ate linhaembranco passo 1
    escrever " "
próximo
escrever "!\n"

para coluna de 1 ate colunas passo 1
    escrever "!"
próximo

fim

22/10

Como "descobrir" que número o usuário digitou? Usando árvore! 

inicio

// Entrada de dados
inteiro numero
texto resultado

escrever "Por favor, digite um número inteiro entre 0 e 7: "
ler numero

// Processamento
se numero > 3.5 então
    se numero > 5.5 então
        se numero > 6.5 então
            resultado <- "7"
        senão
            resultado <- "6"
        fimSe
    senão
        se numero > 4.5 então
            resultado <- "5"
        senão
            resultado <- "4"
        fimSe
    fimSe
senão
    se numero > 1.5 então
        se numero > 2.5 então
            resultado <- "3"
        senão
            resultado <- "2"
        fimSe
    senão
        se numero > 0.5 então
            resultado <- "1"
        senão
            resultado <- "0"
        fimSe
    fimSe
fimSe
  
// Saída de dados
escrever "O número é ", resultado , "."
fim

... ou caso a caso (meio óbvio, mas estamos ainda no terceiro dia de aula, ok? :): 

inicio

// Entrada de dados
inteiro numero
texto resultado

escrever "Por favor, digite um número inteiro entre 0 e 7: "
ler numero

// Processamento
escolhe numero
    caso 9:
        resultado <- "9"
    caso 8:
        resultado <- "8"
    caso 7:
        resultado <- "8"
    caso 6:
        resultado <- "6"
    caso 5:
        resultado <- "5"
    caso 4:
        resultado <- "4"
    caso 3:
        resultado <- "3"
    caso 2:
        resultado <- "2"
    caso 1:
        resultado <- "1"
    defeito:
        resultado <- "0"
fimEscolhe
  
// Saída de dados
escrever "O número é ", resultado , "."
fim

29/10

Lembra como descobrir se um número é primo? Outra forma: 

inicio

inteiro dividendo
escrever "Por favor, digite um número inteiro: "
ler dividendo

inteiro divisores, divisor
real resto
divisores <- 0
para divisor de 2 até (dividendo -1) passo 1
    resto <- dividendo % divisor
    se resto = 0 então
        divisores <- divisores + 1
        escrever "(",divisor,")"
    senão
        escrever "."
    fimSe
próximo

escrever "\nO número ", dividendo, " possui ", divisores, " divisores."
fim

05/11

O mesmo programa do número primo, agora em Bash: 

#!/bin/bash

# Limpa a tela.
clear

# Entrada de dados: pede ao usuário um número inteiro.
echo -n "Por favor, digite um número inteiro: "
read dividendo

# Assume, inicialmente, que o número é primo.
divisores="0"

# Agora, para todos os números compreendidos entre 2 e (número -1)
# é feita a divisão. Se o resto for zero, o número tem divisor e,
# portanto, não é primo.
for divisor in $(seq 2 $(expr ${dividendo} - 1))
do
	# Calcula o resto da divisão.
	resto=$(echo "${dividendo} % ${divisor}" | bc)
	# Verifica se o resto é zero.
	if [ "${resto}" = "0" ]
	then
		# Se for zero, mostra o divisor entre parênteses.
		echo -n "(${divisor})"
		divisores=$(expr ${divisores} + ${divisor})
	else
		# Senão, mostra apenas um ponto na tela.
		echo -n "."
	fi
done
# Apenas formata com uma linha a mais.
echo ""

# Verifica o resultado dos divisores.
if [ "${divisores}" -gt "0" ]
then
	# Se há pelo menos um divisor, não é primo.
	echo "O número não é primo."
else
	# Senão, mantém-se como primo.
	echo "O número é primo."
fi

12/11

Uma outra forma de resolver a questão 3 da primeira prova: 

#!/bin/bash

# Entrada de dados
# Argumento 1: idade da mãe
# Argumento 2: idade do filho mais velho

# Processamento
idadeFilhoDoMeio=$(echo "${2} / 2" | bc)
idadeFilhoMaisNovo=$(echo "${idadeFilhoDoMeio} - 3" | bc)
idadeMaeFilhoMaisVelho=$(echo "${1} - ${2}" | bc)
idadeMaeFilhoDoMeio=$(echo "${1} - ${idadeFilhoDoMeio}" | bc)
idadeMaeFilhoMaisNovo=$(echo "${1} - ${idadeFilhoMaisNovo}" | bc)

# Saída de dados
echo "A mãe teve filho com ${idadeMaeFilhoMaisVelho}, ${idadeMaeFilhoDoMeio} e ${idadeMaeFilhoMaisNovo} anos."

19/11

Um menu: estrutura de decisão combinada com outra, de repetição: 

#!/bin/bash

while [ "${opcao}" != "5" ]
do
	clear
	echo "Sistema: menu principal"
	echo ""
	echo "1) Usuários conectados."
	echo "2) Processos."
	echo "3) Espaço em disco."
	echo "4) Configuração da rede."
	echo "5) Sair do programa."
	echo ""
	echo -n "Escolha a sua opção: "
	read opcao
	case ${opcao} in
		"1")
			w
			;;
		"2")
			ps
			;;
		"3")
			df -h
			;;
		"4")
			ifconfig
			;;
		"5")
			exit
			;;
	esac
	echo ""
	echo -n "Tecle [ENTER] para avançar..."
	read enter
done

Valendo 2 pontos na próxima prova: em Bash, um programa que verifica os números entre 1 e 1000 que são primos e/ou perfeitos. Uma possível resposta: 

#!/bin/bash

for numero in $(seq 1 1000)
do
        divisores="0"
        for divisor in $(seq 2 $(echo "${numero} - 1" | bc))
        do
                resto=$(expr ${numero} % ${divisor})
                if [ "${resto}" = "0" ]
                then
                        divisores=$(expr ${divisores} + ${divisor})
                        echo -n "(${divisor})"
                else
                        echo -n "."
                fi
        done

        # Mostra os valores
        echo -n "${numero}"
        if [ "${divisores}" = "0" ]
        then
                echo -n "p"
        fi
        if [ "$(expr ${divisores} + 1)" = "${numero}" ]
        then
                echo -n "P"
        fi
        echo ""
done

26/11

Verifica se um valor informado pelo usuário é um endereço IPv4: 

#!/bin/sh
#
# O usuário precisa digitar alguma coisa, qualquer coisa.
# Caso contrário, o programa encerrará por falta de informação.
#
# Verifica se o usuário não digitou um argumento.
# Se sim, o programa será encerrado (exit).
if [ "${1}" = "" ]
then
	# Mostra a mensagem de como executar corretamente.
	echo "Use: ${0} (endereço IPv4)"
	# Fecha o programa.
	exit
fi
#
# Separa o primeiro argumento em  4 partes; ou melhor, 4 octetos.
octeto1=$(echo ${1} | cut -d \. -f 1)
octeto2=$(echo ${1} | cut -d \. -f 2)
octeto3=$(echo ${1} | cut -d \. -f 3)
octeto4=$(echo ${1} | cut -d \. -f 4)
#
# Para cada um dos octetos (acima separados), é verificado se
# ele é um número E está entre os limites 0 e 255 (2^8 - 1).
for octeto in ${octeto1} ${octeto2} ${octeto3} ${octeto4}
do
	# Realiza uma soma simples.
	soma=$(echo "${octeto} - 1" | bc)
	# Se a soma falhou ao processar usando o comando "bc",
	# ignorando a exceção zero, significa que não é um número inteiro.
	if [ "${soma}" = "-1" -a "${octeto}" != "0" ]
	then
		echo "${octeto} não é número inteiro."
		exit
	else
		# Caso contrário, é um número inteiro.
		# Próximo passo: verificar se é um byte a compor um IPv4.
		if ! [ "${octeto}" -ge "0" -a "${octeto}" -le "255" ]
		then
			# Está fora dos limites.
			echo "${octeto} é um número qualquer."
			exit
		fi
	fi
done
echo "${1} é um endereço válido."
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Programação_para_Redes_de_Computadores_(técnico)_(diário_2012-2)&oldid=48866”