Algoritmos

O que é um algoritmo?

• Um método para resolver uma classe de problemas; e.g.:
  • calcular o máximo divisor comum de dois inteiros;
  • colocar uma sequência de valores por ordem crescente;
  • encontrar o caminho mais curto entre duas cidades num mapa
• Especificado de forma não-ambigua - uma sequência de instruções precisas
• Efetivo: - executável num número finito de passos com papel e lápis (em princípio)

Testar números primos

Números primos

Um número inteiro positivo \(n\) é primo se for divisível apenas por \(1\) e por \(n\):

2, 3, 5, 7, 11, 13 …

Vamos especificar um algoritmo para testar se um número é primo.

Algoritmo

Dado: \(n\) inteiro.

Se \(n\leq 1\) então não é primo e terminamos imediatamente.

Se \(n>1\) tentamos para \(d = 2, 3, \ldots, n-1\):

• se \(d\) divide \(n\) terminamos (não é primo)
• caso contrário##, continuamos a procurar

Se chegamos ao final sem encontrar um divisor: concluimos que \(n\) é primo.

É um algoritmo

• Testa primalidade para \(n\) qualquer
• Sequência de operações não-ambíguas
  • operações aritméticas elementares
• Termina sempre
  • número finito de possíveis divisores

Implementação

#define FALSE 0
#define TRUE  1

/* Testar se um número inteiro é primo */

int primo(int n) {
   int d;
   if(n <= 1) return FALSE;
   for (d = 2; d < n; d++) {
     if (n%d == 0)  // d divide n?
       return FALSE;
    }
   return TRUE;
}

Observações

• Se \(n\) tem um divisor maior do que \(\sqrt n\), então também tem um divisor inferior a \(\sqrt n\).
• Logo podemos limitar a procura de divisores de 2 até \(\sqrt{n}\)
• Evitamos computação desnecessária quando o número é primo
• Em vez da testar a condição \[d \leq \sqrt{n}\] podemos testar \[d^2 \leq n\] e evitamos o cálculo da raíz quadrada

Implementação (2)

/* Testar se um número é primo; 
   versão mais eficiente */

int primo(int n)
{
   int d;
   if(n <= 1) return FALSE;
   for (d = 2; d*d <= n; d++) {
     if (n%d == 0)   // d divide n
       return FALSE;
    }
   return TRUE;
}

Máximo divisor comum

Exemplo

O máximo divisor comum (mdc) de dois inteiros \(a, b\) é o maior número inteiro que divide \(a\) e \(b\).

Algoritmo de Euclides

Dados: \(a,\, b\) dois números inteiros positivos.

1. se \(a=b\) então terminamos; o mdc é \(a\) e \(b\) (são iguais).
2. se \(a>b\) então:
   \(a \leftarrow a-b\) e repetimos o passo 1.
3. se \(a<b\) então:
   \(b \leftarrow b-a\) e repetimos o passo 1.

Exemplo de execução

Calcular o mdc de 252 e 105.

R: 21

Implementação

/* Calcular o mdc de dois inteiros positivos
   pelo Algoritmo de Euclides (1ª versão)
   */
int mdc(int a, int b)
{
   while (a != b) {
     if(a > b)
         a = a - b;
      else
         b = b - a;
   }
   return a; // a, b são iguais
}

Será um algoritmo?

OK:

• sequência de instruções ✔
• operações não-ambíguas ✔

Questões:

1. Correção: porque obtemos o mdc no final?
2. Terminação: será que o ciclo termina sempre?

Correção

Propriedade da divisão inteira:

Terminação

Em cada iteração:

\[ \begin{aligned} \text{se}~a>b: \quad & (a,b) \longrightarrow (a-b, b) \\ \text{se}~a<b: \quad & (a,b) \longrightarrow (a, b-a) \end{aligned} \]

• No 1º caso diminuimos o valor de \(a\)
• No 2º caso diminuimos o valor de \(b\)
• Como \(a, b\) são sempre inteiros positivos, este processo não pode continuar infinitamente

Observações

• Se \(a\) é muito maior do \(b\) vamos repetidamente subtrair \(b\) a \(a\) até chegar a um resto inferior a \(b\)
• Podemos obter esse resto num só passo efetuando uma divisão inteira
• Por isso a formulação moderna do algoritmo de Euclides usa divisões em vez de subtrações
• Bónus: o algoritmo funciona todos os inteiros não-negativos (incluindo zero)

Algoritmo de Euclides (2)

(Versão usando resto da divisão.)

Dados: \(a,\, b\) dois inteiros não-negativos.

1. se \(b=0\) então terminamos; o mdc é \(a\).
2. caso contrário:
   • \(r\leftarrow\) resto da divisão de \(a\) por \(b\)
   • \(a \leftarrow b\)
   • \(b\leftarrow r\)
   • repetimos o passo 1.

Exemplo

Calcular o mdc de 252 e 105.

R: 21

Implementação

/* Calcular o mdc de dois inteiros usando
   o algoritmo de Euclides (2ª versão)
   */
int mdc(int a, int b)
{
    int r;
    while(b != 0) {
        r = a%b;
        a = b;
        b = r;
    }
    return a;
}

Recursão

Definições recursivas

• A definição de uma função diz-se recursiva se usamos a função na sua própria definição
• Exemplo, a função factorial definida recursivamente:

\[ \begin{eqnarray*} \text{fact}(0) &=& 1\\ \text{fact}(n) &=& n \times \text{fact}(n-1)\,, \quad \text{se}~n>0 \end{eqnarray*} \]

Algoritmos recursivos

A definição anterior define um algoritmo: permite calcular o factorial de qualquer inteiro não negativo.

Exemplo:

\[ \begin{eqnarray*} \text{fact}(4) &=& 4 \times \text{fact}(3) \\ &=& 4 \times (3 \times \text{fact}(2))\\ &=& 4 \times (3 \times (2\times \text{fact}(1)))\\ &=& 4 \times (3 \times (2\times (1\times \text{fact}(0)))\\ &=& 4 \times (3 \times (2\times (1\times 1))) \\ &=& 24 \end{eqnarray*}\]

Recursão em linguagem C

Podemos implementar este processo defindo a função recursiva em C:

int fact(int n)
{
   if (n == 0)
      return 1;              // caso base
   else
      return n * fact(n-1);  // caso recursivo
}

Caso base e recursivo

Há dois casos na definição anterior:

caso base (\(n=0\))

o factorial de zero é 1 (sem mais chamadas recursivas)

caso recursivo (\(n>0\))

calculamos o factorial do natural anterior e multiplicamos o resultado por \(n\)

Terminação de definições recursivas

Para que uma definição recursiva termine é suficiente que:

• tenha (pelo menos) um caso base;
• as chamadas recursivas usem argumentos estritamente inferiores

Observações finais

• Podemos definir o fatorial usando um ciclo em vez de recursão:

  int fact(int n) {
     int r = 1;    // resultado
     for(int i = 1; i<=n; i++) 
         r = r*i;
     return r;
  }

• Para problema simples como o fatorial o ciclo é mais simples e eficiente do que a recursão
• Mais à frente vamos ver problemas em que a solução recursiva é mais simples e eficiente

Tipos básicos

• Vimos dois tipos básicos da linguagem C: int e float
• Vamos agora introduzir mais tipos:
  • inteiros sem sinal
  • inteiros de tamanhos diferentes
  • números vírgula-flutuante de precisão dupla
  • carateres

Inteiros em C

• Os valores de tipo int têm sinal: podem ser negativos, positivos ou zero
• Usamos unsigned int para inteiros sem sinal: apenas positivos ou zero

        int i;          // com sinal
        unsigned int j; // sem sinal 

• Podemos abreviar a declaração para unsigned:

        unsigned j;      // unsigned int 

Inteiros com e sem sinal

• Tipicamente int e unsigned int são ambos representados por palavras de comprimento fixo
  • e.g. 16 ou 32 bits
• A linguagem C não especifica essa representação
• Os computadores usuais usam “complemento para dois” para representar valores com sinal

Exemplo: 16 bits sem sinal

\[ \begin{array}{ccc} \text{mínimo} & 0 & (0000000000000000)_2 \\ & 1 & (0000000000000001)_2 \\ & 2 & (0000000000000010)_2 \\ & \vdots & \vdots \\ \text{máximo} & {2^{16} -1} & (1111111111111111)_2 \end{array} \]

Exemplo: 16 bits com sinal

\[ \begin{array}{ccc} \text{mínimo} & {-2^{15}} & (1000000000000000)_2 \\ & \vdots & \vdots \\ & -1 & (1111111111111111)_2 \\ & 0 & (0000000000000000)_2 \\ & +1 & (0000000000000001)_2 \\ & \vdots & \vdots \\ \text{máximo} & {+2^{15} -1} & (0111111111111111)_2 \end{array} \]

Tamanhos

• O tipo int é tipicamente representado usando 32-bits (pode ser menor em CPUs de 8 e 16-bits)
• Podemos usar atributos long e short para especificar tamanhos maiores ou menores
• Juntamente com unsigned temos 6 tipos diferentes de inteiros:

   short int       unsigned short int
   int             unsigned int 
   long int        unsigned long int

• A ordem dos atributos não importa e podemos omitir o int

Tamanhos

• Sabemos que:
  
  short \(\leq\) int \(\leq\) long
  
  
• A linguagem C não especifica os limites exatos para os tamanhos
• Para cada implementação: o ficheiro “header” <limits.h> define os limites de cada tipo

Imprimir os limites

#include <stdio.h>
#include <limits.h>

int main(void) {
  printf("SHRT_MIN = %d\n", SHRT_MIN);
  printf("SHRT_MAX = %d\n", SHRT_MAX);

  printf("INT_MIN = %d\n", INT_MIN);
  printf("INT_MAX = %d\n", INT_MAX);

  printf("LONG_MIN = %ld\n", LONG_MIN);
  printf("LONG_MAX = %ld\n", LONG_MAX);
     // %ld para formatar long int
}

Exemplo

Execução no meu portátil (GNU/Linux X86-64):

$ ./tamanhos 
SHRT_MIN = -32768
SHRT_MAX = 32767
INT_MIN = -2147483648
INT_MAX = 2147483647
LONG_MIN = -9223372036854775808
LONG_MAX = 9223372036854775807

Constantes

• Constantes inteiras num programa são usualmente int
• Se o valor for demasiado grande então são long int
• Podemos especificar constantes long terminando com L ou l e unsigned com U ou u:

         17   // int
     -1000L   // long int 
     2500UL   // unsigned long int

• Se atribuirmos uma constante de tipo diferente da variável dá-se uma conversão implícita de tipo:

   long int i = 17;     // 17 -> 17L

Ler e escrever inteiros

Para ler ou escrever inteiros short, long ou unsigned devemos usar formatos específicos em scanf e printf.

Casos mais comuns:

"%u"

inteiro decimal unsigned

"%ld"

inteiro decimal long

"%lu"

inteiro decimal unsigned long

Exemplo

• O programa para calcular o volume de uma caixa usava int para as dimensões
• Introduzindo l = w = h = 1500 resulta em overflow (inteiros de 32-bits)
• Vamos modificar o programa:
  • primeiro para usar unsigned
  • depois para usar unsigned long

Versão 1

#include <stdio.h>

int main(void) {
   unsigned l, w, h, v;

   printf("L=?"); scanf("%u", &l);
   printf("W=?"); scanf("%u", &w);
   printf("H=?"); scanf("%u", &h);
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %u*%u*%u (cm)\n", l,w,h);
   printf("Volume: %u (cm^3)\n", v);
}

Execução 1

Esta versão calcula o volume correto para

l = w = h = 1500

mas obtemos de novo overflow para

l = w = h = 2000

Versão 2

#include <stdio.h>

int main(void) {
   unsigned long l, w, h, v;

   printf("L=?"); scanf("%lu", &l);
   printf("W=?"); scanf("%lu", &w);
   printf("H=?"); scanf("%lu", &h);
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %lu*%lu*%lu (cm)\n", l,w,h);
   printf("Volume: %lu (cm^3)\n", v);
}

Execução 2

• Calcula resultado correto para l = w = h = 2000
• Exercício: descobrir os maiores valores l = w = h para os quais não ocorre overflow (assumindo unsigned long com 64-bits)

Vírgula flutuante

• Dois tipos básicos para vírgula flutuante:
  • float para precisão simples;
  • double para precisão dupla.
• O padrão da linguagem não define a precisão destes tipos
• As implementações modernas usualmente seguem um standard chamado IEEE 754

Limites IEEE 754

• double é usado para a maior parte das aplicações
• float é usando apenas se a precisão for pouco importante ou para poupar memória

Constantes

• Podemos escrever constantes virgula flutuante de várias formas:
  
  57.0 57. 57E0 5.7e1
  
  
• A constante tem uma mantissa e opcionalmente um expoente
• O expoente indica a potência de 10 que multiplica a mantissa e é prececedido da letra E (ou e)

Ler e escrever vírgula flutuante

• Devemos usar o formato "%lf" para ler valores double
• Mas: para imprimir float ou double devemos usar apenas "%f"
• Podemos também ainda usar "%g" para formatar usando notação científica

Exemplo

#include <stdio.h>

int main(void) {
  double l, w, h, v;

  printf("L=?"); scanf("%lf", &l);
  printf("W=?"); scanf("%lf", &w);
  printf("H=?"); scanf("%lf", &h);
  v = l*w*h; // cálculo do volume

  printf("LxWxH: %.3f*%.3f*%.3f (cm)\n", 
         l, w, h);
  printf("Volume: %.3g (cm^3)\n", v);
}

Conversões explícitas

Conversão explicita de tipos (“cast”):

• A expressão é calculada pelas regras usuais
• Usar parêntesis se necessário

int k = 2, n = 3; 
printf("%f\n", (float)k/(float)n); // 0.66666
printf("%f\n", (float)k/n);        // 0.66666
printf("%f\n", (float)(k/n));      // 0.00000

Conversões explícitas (cont.)

Também podemos converter entre tamanhos:

int i = 1500;
long j;
j = (long)i;

Devemos efetuar conversões antes de operações que possam causar overflow:

int i = 1500;
long j;
j = (long)(i*i*i);  // "overflow"(?)
j = (long)i*i*i;    // OK