01 Fundamentos Da Computação

FUNDAMENTOS DA COMPUTAÇÃO
Fundamentos Da Computação
Algoritmos
Embora as vezes não percebemos, utilizamos algoritmos no nosso dia-a-dia e não sabemos. Para a
execução de alguma tarefa ou mesmo resolver algum problema, muitas vezes inconscientemente
executamos algoritmos. Mas o que é Algoritmo?
Algoritmo é simplesmente uma "receita" para executarmos uma tarefa ou resolver algum problema. E
como toda receita, um algoritmo também deve ser finito. Se seguirmos uma receita de bolo
corretamente, conseguiremos fazer o bolo. A computação utiliza muito esse recurso, então se você
pretende aprender programação, obviamente deve saber o que é algoritmo.
Exemplo De Algoritmo
Imagine o trabalho de um recepcionista de cinema, ele deve conferir os bilhetes e direcionar o cliente
para a sala correta. Além disso, se o cliente estiver 30 minutos adiantado o recepcionista deve
informar que a sala do filme ainda não está aberta. E quando o cliente estiver 30 minutos atrasado o
recepcionista deve informar que a entrada não é mais permitida
Obs: Essas regras não são 100% verdade, eu as defini neste post apenas para fins didáticos
Vamos escrever um algoritmo para descrever a atividade do recepcionista.
Algoritmo Recepcionista De Cinema
1 - Solicitar ao cliente o bilhete do filme.
2 - Conferir a data e o horário do filme no bilhete.
Se data/hora atual > data/hora do filme + 30 minutos Então
3 - Informar ao cliente que o tempo limite para entrada foi excedido.
4 - Não permitir a entrada.
Senão Se data/hora atual < data/hora do filme - 30 minutos Então
5 - Informar ao cliente que a sala do filme ainda não foi liberada para entrada.
6 - Não permitir a entrada.
Senão
7 - Permitir a entrada.
8 - Indicar ao cliente onde fica a sala do filme.
Fim-Se
Fim
Qualquer pessoa que seguir esses passos executará a função do recepcionista do cinema.
Concorda? É importante notar que o algoritmo tem um fluxo que pode seguir diferentes caminhos
dependendo da situação em que se encontra. Outro aspecto interessante é que o algoritmo é finito,
uma hora ele tem que acabar! Vejamos outro exemplo, dessa vez com uma representação visual:
Como trocar uma lâmpada?
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
WWW.DOMINACONCURSOS.COM.BR 1
Esta representação gráfica do algoritmo é chamada de fluxograma. Os losangos representam as

decisões que são tomadas para executar um ou outro passo. Ao final, a lâmpada tem que estar
funcionando.
Algoritmos Na Computação
Todas as tarefas executadas pelo computador, são baseadas em Algoritmos. Logo, um algoritmo
deve também ser bem definido, pois é uma máquina que o executará. Uma calculadora por exemplo,
para executar a operação de multiplicação, executa um algoritmo que calcula somas até um
determinado número de vezes. Abaixo, um exemplo do algoritmo de multiplicação. Para facilitar,
consideremos que os fatores da multiplicação são positivos.
Algoritmo Multiplição de números positivos
Declaração de variáveis
numero1, numero2, resultado, contador: Inteiro
Inicio
ler(numero1)
ler(numero2)
resultado <- 0
contador <- 0
Enquanto contador < numero2 Faça
resultado <- resultado + numero1
contador <- contador + 1
Fim-Enquanto
escrever(resultado)
Fim
Este algoritmo pode ser considerado complexo por iniciantes, mas algoritmos deste tipo, utilizando
variáveis e controle de fluxo, é muito comum em programação. Se você quer aprender programação,
é necessário entendê-lo, se não conseguiu, leia-o novamente com mais atenção. Para ajudar, vamos
definir algumas coisas importantes sobre o algoritmo:
Variável é um espaço alocado na memória para armazenar dados. No algoritmo, foram criadas 4
variáveis.
O símbolo "<-" representa uma atribuição de valor a uma variável. Por exemplo, (resultado <=
resultado + numero1) atribui à variável resultado, o valor da própria variável resultado, acrescido do
valor da variável numero1.
O comando "ler(numero1)", significa que o algoritmo está lendo o que o usuário digita e armazenando
na variável numero1.
O comando Enquanto é uma estrutura de controle de fluxo do tipo "Estrutura de repetição".
O comando escrever(resultado) exibe na tela o valor da variável resultado.
Com o tempo, a leitura e criação de algoritmos passa a ser uma coisa muito simples para um
programador. Mas para isso é preciso bastante prática! Então, você pode começar fazendo um
exercício, crie algoritmos para as suas tarefas do dia-a-dia a partir do momento em que você acorda.
Essa é a melhor forma de aprender a criar algoritmos.
Método Iterativo
Em matemática computacional, um método iterativo é um procedimento que gera uma sequência de

soluções aproximadas que vão melhorando conforme iterações são executadas, e resolvem uma
classe de problemas estabelecida. Uma implementação específica de um método iterativo, incluindo
o critério para a parada é um algoritmo iterativo. Um método iterativo é considerado convergente se a
sequência correspondente converge, dado uma tolerância inicial de aproximação. Uma análise
rigorosa de convergência de um método iterativo geralmente é efetuada, no entanto, métodos
iterativos baseados em heurísticas são comuns.
Alguns exemplos de métodos iterativos para a resolução de sistemas de equações lineares são:
Método de Jacobi, Método de Gauss-Seidel, Método do gradiente conjugado.
Recursão E Algoritmos Recursivos
Muitos problemas têm a seguinte propriedade: cada instância do problema contém uma instância
menor do mesmo problema. Dizemos que esses problemas têm estrutura recursiva. Para resolver um
tal problema, podemos aplicar o seguinte método:
se a instância em questão for pequena, resolva-a diretamente (use força bruta se necessário);
senão, reduza-a a uma instância menor do mesmo problema, aplique o método à instância menor,
volte à instância original.
A aplicação desse método produz um algoritmo recursivo. Para mostrar como isso funciona,
examinaremos um exemplo concreto.
Um Exemplo De Problema
Considere o seguinte problema: Determinar o valor de um elemento máximo de um vetor v[0..n-1] . É

claro que o problema só faz sentido se o vetor não é vazio, ou seja, se n ≥ 1.
Para preparar o terreno, examine uma tradicional solução iterativa do problema:
int maximo (int n, int v[]) {
int x;
x = v[0];
for (int j = 1; j < n; j += 1)
if (x < v[j]) x = v[j];
return x;
Exercícios 1
Considere a função iterativa maximo acima. Faz sentido trocar x = v[0] por x = 0, como fazem alguns
programadores descuidados? Faz sentido trocar x = v[0] por x = INT_MIN? Faz sentido trocar x < v[j]
por x <= v[j]? [Veja uma solução parcial.]
A função abaixo promete encontrar o valor de um elemento máximo de v[0..n-1]. A função cumpre a
promessa?
int maxi (int n, int v[]) {
int m = v[0];
for (int j = 1; j < n; ++j)
if (v[j-1] < v[j]) m = v[j];
return m;
Que tipos de problemas um algoritmo recursivo é capaz de resolver?
Solução recursiva do exemplo
Eis uma solução recursiva do problema da seção anterior:
int
maximoR (int n, int v[])
if (n == 1)
return v[0];
else {
int x;
x = maximoR (n-1, v);
// x é o máximo de v[0..n-2]
if (x > v[n-1]) return x;
else return v[n-1];
A análise da correção do algoritmo tem a mesma forma que uma prova por indução. Se n vale 1
então v[0] é o único elemento relevante do vetor e portanto v[0] é o máximo. Agora suponha que n
vale mais que 1. Então nosso vetor tem duas partes: v[0..n-2] e v[n-1] e portanto o valor que
procuramos é o maior dentre
v[n-1] e o máximo de v[0..n-2].
A função devolve o maior desses dois números, e portanto está correta.
Para que uma função recursiva seja compreensível, é muito importante que o autor da função diga,
explicitamente, o que a função faz. Portanto, eu deveria escrever o seguinte comentário antes do
código:
// Ao receber v e n >= 1, a função devolve
// o valor de um elemento máximo
// do vetor v[0..n-1].
(Eis um roteiro que pode ajudar a verificar se uma função recursiva está correta: 1. Escreva o que a
função deve fazer. 2. Verifique que a função de fato faz o que deveria quando n é pequeno (por
exemplo, quando n ≤ 1). 3. Imagine que n é grande (por exemplo, n > 1) e verifique que a função faz
a coisa certa supondo que faria a coisa certa se no lugar de n tivéssemos algo menor que n.)
Desempenho. Algumas pessoas acreditam que funções recursivas são inerentemente ineficientes e
lentas, mas isso não passa de lenda. Talvez a lenda tenha origem em usos descuidadas da recursão,
como num dos exercícios abaixo. (Nem tudo são flores, entretanto. É preciso lembrar do espaço de
memória que a pilha de recursão consome.)
Como o computador executa um algoritmo recursivo? Embora relevante, essa pergunta será ignorada
por enquanto. (Veja o capítulo sobre pilhas.)
Exercícios 2
Verifique que a seguinte maneira de escrever a função maximoR é exatamente equivalente à vista
acima:
int maximoR (int n, int v[]) {
int x;
if (n == 1) x = v[0];
else {
x = maximoR (n-1, v);
if (x < v[n-1]) x = v[n-1];
return x;
Critique a seguinte função recursiva; ela promete encontrar o valor de um elemento máximo de v[0..n-
1].
int maximoR1 (int n, int v[]) {
if (n == 1) return v[0];
if (n == 2) {
if (v[0] < v[1]) return v[1];
else return v[0];
int x = maximoR1 (n-1, v);
if (x < v[n-1]) return v[n-1];
else return x;
Critique a seguinte função recursiva, que promete encontrar o valor de um elemento máximo de
v[0..n-1].
int maximoR2 (int n, int v[]) {
if (maximoR2 (n-1, v) < v[n-1])
return v[n-1];
else
return maximoR2 (n-1, v);
Programa de teste. Escreva um pequeno programa para testar a função recursiva maximoR. O seu
programa deve esperar que o usuário digite uma sequência de números e em seguida devolver o
valor do maior dos números digitados. [Veja uma solução.] Agora faça uma nova versão do programa
para determinar um elemento máximo de um vetor aleatório. Acrescente ao seu programa uma
função que confira a resposta dada por maximoR. [Veja uma solução]
Escreva uma função recursiva maxmin que calcule o valor de um elemento máximo e o valor de um
elemento mínimo de um vetor v[0..n-1]. Quantas comparações envolvendo os elementos do vetor sua
função faz?
Escreva uma função recursiva que calcule a soma dos elementos positivos do vetor de inteiros v[0..n-
1]. O problema faz sentido quando n é igual a 0? Quanto deve valer a soma nesse caso?
Escreva uma função recursiva que calcule o produto dos elementos estritamente positivos de um
vetor de inteiros v[0..n-1]. O problema faz sentido quando todos os elementos do vetor são nulos? O
problema faz sentido quando n vale 0? Quanto deve valer o produto nesses casos?
Outra solução recursiva
A função maximoR discutida acima aplica a recursão ao segmento v[0..n-2] do vetor. É possível
escrever uma versão que aplique a recursão ao segmento v[1..n-1]:
// Ao receber v e n >= 1, esta função devolve
// o valor de um elemento máximo do vetor
// v[0..n-1].
int
maximo2 (int n, int v[])
return maxR (0, n, v);
A função maximo2 é apenas uma embalagem ou invólucro (= wrapper-function); o serviço pesado é

executado pela função recursiva maxR:
// Recebe v e i < n e devolve o valor de
// um elemento máximo do vetor v[i..n-1].
int
maxR (int i, int n, int v[])
if (i == n-1) return v[i];
else {
int x;
x = maxR (i + 1, v);
if (x > v[i]) return x;
else return v[i];
A função maxR resolve um problema mais geral que o original. A necessidade de generalizar o
problema original ocorre com frequência no projeto de algoritmos recursivos.
A título de curiosidade, eis outra maneira, talvez surpreendente, de aplicar recursão ao segmento
v[1..n-1]. Ela usa aritmética de endereços:
int maximo2R (int n, int v[]) {
int x = maximo2R (n - 1, v + 1);
if (x > v[0]) return x;
return v[0];
Exercícios 3
A seguinte função recursiva pretende encontrar o valor de um elemento máximo de v[p..u], supondo p
≤ u. (O índice p aponta o primeiro elemento do vetor e o índice u aponta o último.) A função está
correta? Suponha que p e u valem 0 e 6 respectivamente e mostre a sequência, devidamente
indentada, de chamadas de max.
int max (int p, int u, int v[]) {
if (p == u) return v[u];
else {
int m, x, y;
m = (p + u)/2; // p ≤ m < u
x = max (p, m, v);
y = max (m+1, u, v);
if (x >= y) return x;
else return y;
Escreva uma função recursiva que calcule a soma dos elementos positivos do vetor v[p..u-1]. O
problema faz sentido quando p é igual a u? Quanto deve valer a soma nesse caso?
Critique a documentação do seguinte código:
// Recebe um vetor de tamanho n
// e devolve a soma do vetor.
int soma (int v[], int n) {
return sss (v, n+1);
int sss (int v[], int n) {
if (n == 1) return 0;
return sss (v, n-1) + v[n-1];
Diga o que a função abaixo faz. Para quais valores dos parâmetros sua resposta está correta?
int ttt (int x[], int n) {
if (x[n] > 100) return x[n] + ttt (x, n-1);
else return ttt (x, n-1);
Escreva uma função recursiva que calcule a soma dos dígitos de um inteiro estritamente positivo n. A
soma dos dígitos de 132, por exemplo, é 6.
Escreva uma função recursiva que calcule o piso do logaritmo de N na base 2. (Veja uma versão
iterativa do exercício.)
Exercícios 4
Qual o valor de X (4) se X é dada pelo seguinte código? [Veja uma solução.]
int X (int n) {
if (n == 1 || n == 2) return n;
else return X (n-1) + n * X (n-2);
Qual é o valor de f (1,10)? Escreva uma função equivalente que seja mais simples.
double f (double x, double y) {
if (x >= y) return (x + y)/2;
else return f (f (x+2, y-1), f (x+1, y-2));
Qual o resultado da execução do seguinte programa?
int ff (int n) {
if (n % 2 == 0) return ff (n/2);
return ff ((n-1)/2) + ff ((n+1)/2);
int main (void) {
printf ("%d", ff(7));
return EXIT_SUCCESS;
Execute fusc (7,0). Mostre a sequência, devidamente indentada, das chamadas a fusc.
int fusc (int n, int profund) {
for (int i = 0; i < profund; ++i)
printf (" ");
printf ("fusc(%d,%d)\n", n, profund);
if (n = 1)
return 1;
if (n % 2 == 0)
return fusc (n/2, profund+1);
return fusc ((n-1)/2, profund+1) +
fusc ((n+1)/2, profund+1);
Importante. Critique a seguinte função recursiva:
int XX (int n) {
else return XX (n/3+1) + n;
Fibonacci. A função de Fibonacci é definida assim: F(0) = 0, F(1) = 1 e F(n) = F(n-1) + F(n-2) para n >
1. Descreva a função F em linguagem C. Faça uma versão iterativa e uma recursiva.
Seja F a versão recursiva da função de Fibonacci. O cálculo do valor da expressão F(3) provocará a
seguinte sequência de invocações da função:
F(3)
F(2)
F(1)
F(0)
F(1)
Qual a sequência de invocações da função durante o cálculode F(5)?
Euclides. A seguinte função calcula o maior divisor comum dos inteiros estritamente positivos m e n.
Escreva uma função recursiva equivalente.
int Euclides (int m, int n) {
int r;
do {
r = m % n;
m = n;
n = r;
} while (r != 0);
return m;
Exponenciação. Escreva uma função recursiva eficiente que receba inteiros estritamente positivos k e
n e calcule kn. (Suponha que kn cabe em um int.) Quantas multiplicações sua função executa
aproximadamente? .
Régua inglesa [Sedgewick 5.8, Roberts 5.11] Escreva uma função recursiva que imprima uma régua
de ordem n no intervalo [0..2n]. O traço no ponto médio da régua deve ter comprimento n, os traços
nos pontos médios dos subintervalos superior e inferior devem ter comprimento n−1, e assim por
diante.
Teste De Mesa
O Teste de Mesa é um processo manual que é utilizado para validar a lógica de um determinado
algoritmo. Ele é utilizado principalmente em algoritmos quando a linguagem utilizada não possui
nenhuma ferramenta automatizada de depuração. Como as linguagens de programação costumam
possuir tais ferramentas, é mais comum utilizá-las a fazer o teste de mesa propriamente dito, embora
para quem ainda é iniciante, eu particularmente ainda recomendo utilizá-lo, visto que provavelmente
não terá domínio sobre a ferramenta de depuração
Como é possível aplicá-lo para fazer a verificação da lógica em um programa?
Não há uma forma canônica para a elaboração de um Teste de Mesa, pois dependerá muito do que
pretende verificar no algoritmo e do seu nível de entendimento. No geral, você deverá criar no papel
uma tabela com todas as variáveis do programa e executar passo a passo seu código, anotando
sempre os valores das variáveis. Assim você será capaz de identificar se os valores condizem com o
esperado ou localizar a exata linha de código onde o valor da variável passa a ficar errado.
O livro Técnicas de Programação - Uma Abordagem Moderna supracitado apresenta também um

procedimento de quatro passos que descrevem a execução do Teste de Mesa:
Elaborar uma tabela onde cada coluna se refere a cada variável envolvida e o resultado de uma
operação em particular (ou observação pertinente);
Executar os passos previstos no algoritmo;
Verificar se os resultados obtidos são coerentes com os previstos;
Encerrar o teste após um número razoável de resultados corretos obtidos;
Ou seja, identifique todas as variáveis do seu programa e verifique os valores das mesmas a cada
linha de código executada.
Qual É O Passo A Passo Para Efetuar O Teste De Mesa?
Como dito, não há uma sequências de passos definitiva, mas as que eu costumo seguir e que
sempre tiveram uma boa aceitação por iniciantes em programação é:
Identifique todas as variáveis no seu programa;
Crie uma tabela onde a primeira coluna se chama "Passo", a segunda de chama "Linha". A partir
disto, crie uma coluna para cada variável do programa;
Na primeira linha da tabela, preencha a coluna "Passo" com "Início", pode deixar a coluna "Linha" em
branco e preencha cada coluna das variáveis com os respectivos valores iniciais;
Percorra seu código linha a linha, preenchendo a tabela. A coluna "Passo" deverá ser incrementada a
cada nova linha na tabela; a coluna "Linha" deve indicar o número da linha no código que está sendo
analisada e em cada coluna das variáveis deve constar o respectivo valor para cada variável após a
linha de código ser executada;
Execute O Passo 4 Até O Programa Finalizar;
Por exemplo, vamos considerar um programa que praticamente todos os iniciantes fazem no início
dos estudos: cálculo do fatorial. Um algoritmo para pseudocódigo de cálculo do fatorial é:
1 numero <- 0;
2 resultado <- 1;
4 leia(numero);
6 se (numero < 0) então
7 imprima("O número não pode ser negativo");
8 senão
9 enquanto (numero > 0) faça
10 resultado <- resultado * numero;
11 numero <- numero - 1;
12 fim
13
14 imprima("O fatorial de vale", resultado);
15 fim
Lógica De Programação
Lógica de Programação é a técnica de desenvolver algoritmos (sequências lógicas) para atingir

determinados objetivos dentro de certas regras baseadas na Lógica matemática e em outras teorias
básicas da Ciência da Computação e que depois são adaptados para a Linguagem de Programação
utilizada pelo programador para construir seu software.
Um algoritmo é uma sequência não ambígua de instruções que é executada até que determinada
condição se verifique. Mais especificamente, em matemática, constitui o conjunto de processos (e
símbolos que os representam) para efetuar um cálculo.
O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita, embora muitos
algoritmos sejam mais complexos. Eles podem repetir passos (fazer iterações) ou necessitar de
decisões (tais como comparações ou lógica) até que a tarefa seja completada. Um algoritmo
corretamente executado não irá resolver um problema se estiver implementado incorretamente ou se
não for apropriado ao problema.
Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos

necessários para realizar uma tarefa. Sua implementação pode ser feita por um computador, por
outro tipo de autômato ou mesmo por um ser humano. Diferentes algoritmos podem realizar a mesma
tarefa usando um conjunto diferenciado de instruções em mais ou menos tempo, espaço ou esforço
do que outros. Tal diferença pode ser reflexo da complexidade computacional aplicada, que depende
de estruturas de dados adequadas ao algoritmo. Por exemplo, um algoritmo para se vestir pode
especificar que você vista primeiro as meias e os sapatos antes de vestir a calça enquanto outro
algoritmo especifica que você deve primeiro vestir a calça e depois as meias e os sapatos. Fica claro
que o primeiro algoritmo é mais difícil de executar que o segundo apesar de ambos levarem ao
mesmo resultado.
O conceito de um algoritmo foi formalizado em 1936 pela Máquina de Turing de Alan Turing e pelo
cálculo lambda de Alonzo Church, que formaram as primeiras fundações da Ciência da Computação.
Formalismo
Um programa de computador é essencialmente um algoritmo que diz ao computador os passos

específicos e em que ordem eles devem ser executados, como por exemplo, os passos a serem
tomados para calcular as notas que serão impressas nos boletins dos alunos de uma escola. Logo, o
algoritmo pode ser considerado uma sequência de operações que podem ser simuladas por uma
máquina de Turing completa.
Quando os procedimentos de um algoritmo envolvem o processamento de dados, a informação é lida

de uma fonte de entrada, processada e retornada sob novo valor após processamento, o que
geralmente é realizado com o auxílio de uma ou mais estruturas de dados.
Para qualquer processo computacional teórico, o algoritmo precisa estar rigorosamente definido,
especificando a maneira que ele se comportará em todas as circunstâncias. A corretude do algoritmo
pode ser provada matematicamente, bem como a quantidade assintótica de tempo e espaço
(complexidade) necessários para a sua execução. Estes aspectos dos algoritmos são alvo da análise
de algoritmos. As implementações, porém, podem se limitar a casos específicos.
A maneira mais simples de se pensar um algoritmo é por uma lista de procedimentos bem definida,
no qual as instruções são executadas passo a passo a partir do começo da lista, uma ideia que pode
ser facilmente visualizada através de um fluxograma. Tal formalização adota as premissas da
programação imperativa, que é uma forma mecânica para visualizar e desenvolver um algoritmo.
Concepções alternativas para algoritmos variam em programação funcional e programação lógica.
Término Do Algoritmo
Alguns autores restringem a definição de algoritmo para procedimentos que eventualmente terminam.
Minksy constatou que se o tamanho de um procedimento não é conhecido de antemão, tentar
descobri-lo é problema indecidível já que o procedimento pode ser executado infinitamente, de forma
que nunca se terá a resposta. Alan Turing provou em 1936 que não existe máquina de Turing para
realizar tal análise para todos os casos, logo não há algoritmo para realizar tal tarefa para todos os
casos. Tal condição é conhecida atualmente como problema da parada. Basicamente, isto quer dizer
que não existe um programa de computador que possa antever, de forma geral, se um outro
programa de computador vai parar algum dia.
Para algoritmos intermináveis o sucesso não pode ser determinado pela interpretação da resposta e
sim por condições impostas pelo próprio desenvolvedor do algoritmo durante sua execução. Por
exemplo, podemos querer um algoritmo interminável para controlar um sinal de trânsito.
Implementação
A maioria dos algoritmos é desenvolvida para ser implementada em um programa de computador.

Apesar disso eles também podem ser implementados por outros modos tais como uma rede neural
biológica (tal como no cérebro quando efetuamos operações aritméticas) em circuitos elétricos ou até
mesmo em dispositivos mecânicos.
Para programas de computador existe uma grande variedade de linguagens de programação, cada
uma com características específicas que podem facilitar a implementação de determinados algoritmos
ou atender a propósitos mais gerais.
Tabela Verdade
Tabela verdade, tabela de verdade ou tabela veritativa é um tipo de tabela matemática usada em
Lógica para determinar se uma fórmula é válida ou se um sequente é correto.
As tabelas verdade derivam do trabalho de Gottlob Frege, Charles Peirce e outros nomes da década
de 1880, e tomaram a forma atual em 1922 através dos trabalhos de Emil Post e Ludwig Wittgenstein.
A publicação do Tractatus Logico-Philosophicus, de Wittgenstein, utilizava as mesmas para classificar
funções veritativas em uma série. A vasta influência de seu trabalho levou, então, à difusão do uso de
tabelas verdade.
Como Construir Uma Tabela Verdade
Uma tabela verdade consiste em:
uma linha em que estão contidos todas as subfórmulas de uma fórmula. Por exemplo, a fórmula
¬((A∧B)→C) tem o seguinte conjunto de subfórmulas:
{ ¬((A∧B)→C) , (A∧B)→C , A∧B , A , B , C}
L linhas em que estão todos possíveis valores que os termos podem receber e os valores cujas
fórmulas moleculares tem dados os valores destes termos;
o número destas linhas é L = nt , sendo n o número de valores que o sistema permite (sempre 2 no
caso do cálculo proposicional clássico) e t o número de termos que a fórmula contém; assim, se uma
fórmula contém 2 termos, o número de linhas que expressam a permutações entre estes será 4: um
caso de ambos termos serem verdadeiros (V V), dois casos de apenas um dos termos ser verdadeiro
(V F , F V) e um caso no qual ambos termos são falsos (F F). Se a fórmula contiver 3 termos, o
número de linhas que expressam a permutações entre estes será 8: um caso de todos termos serem
verdadeiros (V V V), três casos de apenas dois termos serem verdadeiros (V V F , V F V , F V V), três
casos de apenas um dos termos ser verdadeiro (V F F , F V F , F F V) e um caso no qual todos
termos são falsos (F F F).
Para proposições com mais de 3 termos, basta seguir o mesmo raciocínio apresentado nas imagens
acima.
Tabelas Das Principais Operações Do Cálculo Proposicional
Negação (~)
A ~A
V F
F V
A negação da proposição "A" é a proposição "~A", de maneira que se "A" é verdade então "~A" é
falsa, e vice-versa.
Obs.: Usando o Excel, tal proposição pode ser expressado da seguinte maneira: =NÃO(C1;C2)
Conjunção (^)
A B A^B
V V V
V F F
F V F
F F F
A conjunção é verdadeira se e somente se ambos os operandos são verdadeiros.
Obs.: Usando o Excel, tal proposição pode ser expressado da seguinte maneira: =E(C1;C2)
Disjunção (V)
A B AvB
V V V
V F V
F V V
F F F
A disjunção é falsa se, e somente se ambos os operandos forem falsos.
Obs.: Usando o Excel, tal proposição pode ser expressado da seguinte maneira: =OU(C1;C2)
Condicional (Se... Então)
A B A→B
V V V
V F F
F V V
F F V
A condicional é falsa se, e somente se, o primeiro operando é verdadeiro e o segundo operando é
falso.
Bicondicional (Se E Somente Se)
A B A↔B
V V V
V F F
F V F
F F V
A bicondicional é verdadeira se, e somente se, ambos operandos forem falsos ou ambos verdadeiros.
Disjunção Exclusiva (Ou Exclusivo... Ou Xor)
A B A∨B
V V F
V F V
F V V
F F F
A disjunção exclusiva é verdadeira se, e somente se, apenas um dos operandos for verdadeiro.
Adaga De Quine (NOR)
A B A∨B A↓B
V V V F
V F V F
F V V F
F F F V
A Adaga de Quine (negação da disjunção) é verdadeira se e somente se os operandos são falsos.
Como usar tabelas para verificar a validade de argumentos
Verifique se a conclusão nunca é falsa quando as premissas são verdadeiras. Em caso positivo, o
argumento é válido. Em caso negativo, é inválido.
Alguns Argumentos Válidos
Modus Ponens
{\displaystyle \left\{A\to B\ ,A\right\}\vDash B} \left \{A\to B\ , A\right \}\vDash B
A B A→B
V V V
V F F
F V V
F F V
[2]
Modus Tollens
{\displaystyle \left\{A\to B\ ,\neg B\right\}\vDash \neg A} \left \{A\to B\ , \neg B\right \}\vDash \neg A
A B ¬A ¬B A→B
V V F F V
V F F V F
F V V F V
F F V V V
Silogismo Hipotético
{\displaystyle \left\{A\to B,B\to C\right\}\vDash A\to C} \left \{A\to B , B\to C\right\}\vDash A\to C
A B C A→B B→C A→C
V V V V V V
V V F V F F
V F V F V V
V F F F V F
F V V V V V
F V F V F V
F F V V V V
F F F V V V
Algumas Falácias
Afirmação do consequente
Se A, então B. (A→B)
B.
Logo, A.
A B A→B
V V V
V F F
F V V
F F V
Comutação Dos Condicionais
A implica B. (A→B)
Logo, B implica A. (B→A)
A B A→B B→A
V V V V
V F F V
F V V F
F F V V
Como Usar Tabelas Para Verificar A Equivalência De Fórmulas
(A∧B) ≡ ¬(B→¬A) ≡ ¬(¬A∨¬B) ≡ (¬A↓¬B)
A B ¬A ¬B A∧B B→¬A ¬(B→¬A) (¬A↓¬B)
V V F F V F V V
V F F V F V F F
F V V F F V F F
F F V V F V F F
(A→B) ≡ ¬(A∧¬B) ≡ (¬A∨B) ≡ ¬(¬A↓B)
A B ¬A ¬B A→B A∧¬B ¬(A∧¬B) ¬A∨B
V V F F V F V V
V F F V F V F F
F V V F V F V V
F F V V V F V V
(A∨B) ≡ ¬(¬A∧¬B) ≡ (¬A→B) ≡ ¬(A↓B)
A B ¬A ¬B ¬A∧¬B ¬(¬A∧¬B) ¬A→B ¬(A↓B)
V V F F F V V V
V F F V F V V V
F V V F F V V V
F F V V V F F F
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

01 Fundamentos Da Computação

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

01 Fundamentos Da Computação

Загружено:

Авторское право:

Доступные форматы

FUNDAMENTOS DA COMPUTAÇÃO

Vamos escrever um algoritmo para descrever a atividade do recepcionista.

Algoritmo Recepcionista De Cinema

1 - Solicitar ao cliente o bilhete do filme.

2 - Conferir a data e o horário do filme no bilhete.

Se data/hora atual > data/hora do filme + 30 minutos Então

3 - Informar ao cliente que o tempo limite para entrada foi excedido.

4 - Não permitir a entrada.

Senão Se data/hora atual < data/hora do filme - 30 minutos Então

6 - Não permitir a entrada.

8 - Indicar ao cliente onde fica a sala do filme.

Esta representação gráfica do algoritmo é chamada de fluxograma. Os losangos representam as

Algoritmo Multiplição de números positivos

numero1, numero2, resultado, contador: Inteiro

Enquanto contador < numero2 Faça

resultado <- resultado + numero1

contador <- contador + 1

O comando Enquanto é uma estrutura de controle de fluxo do tipo "Estrutura de repetição".

O comando escrever(resultado) exibe na tela o valor da variável resultado.

Em matemática computacional, um método iterativo é um procedimento que gera uma sequência de

Recursão E Algoritmos Recursivos

Considere o seguinte problema: Determinar o valor de um elemento máximo de um vetor v[0..n-1] . É

Para preparar o terreno, examine uma tradicional solução iterativa do problema:

int maximo (int n, int v[]) {

for (int j = 1; j < n; j += 1)

if (x < v[j]) x = v[j];

int maxi (int n, int v[]) {

for (int j = 1; j < n; ++j)

if (v[j-1] < v[j]) m = v[j];

Que tipos de problemas um algoritmo recursivo é capaz de resolver?

Solução recursiva do exemplo

Eis uma solução recursiva do problema da seção anterior:

maximoR (int n, int v[])

x = maximoR (n-1, v);

if (x > v[n-1]) return x;

else return v[n-1];

v[n-1] e o máximo de v[0..n-2].

A função devolve o maior desses dois números, e portanto está correta.

// Ao receber v e n >= 1, a função devolve

// o valor de um elemento máximo

int maximoR (int n, int v[]) {

x = maximoR (n-1, v);

if (x < v[n-1]) x = v[n-1];

int maximoR1 (int n, int v[]) {

if (v[0] < v[1]) return v[1];

else return v[0];

int x = maximoR1 (n-1, v);

if (x < v[n-1]) return v[n-1];

int maximoR2 (int n, int v[]) {

if (maximoR2 (n-1, v) < v[n-1])

return maximoR2 (n-1, v);

Outra solução recursiva

// Ao receber v e n >= 1, esta função devolve

// o valor de um elemento máximo do vetor

maximo2 (int n, int v[])

return maxR (0, n, v);

A função maximo2 é apenas uma embalagem ou invólucro (= wrapper-function); o serviço pesado é

// Recebe v e i < n e devolve o valor de

// um elemento máximo do vetor v[i..n-1].

maxR (int i, int n, int v[])

if (i == n-1) return v[i];

if (x > v[i]) return x;

else return v[i];

int maximo2R (int n, int v[]) {