• Todo ano, inúmeros problemas de Matemática são temas de questões de competições de programação!


• Esse fato é natural já que a Matemática é a base da Computação.


• Alguns problemas que envolvem Matemática são ad-hoc. Alguns exemplos podem ser encontrados na lista de exercícios.


• Nesta aula apresentaremos tópicos sobre Aritmética e Álgebra.

• As linguagens C/C++, Java e Python oferecem bibliotecas nativas para manipulações algébricas e aritméticas.

C/C++ (cstdlib):

          
// inclusão da biblioteca
#include <cstdlib>
using namespace std;

// números aleatórios
int s = srand();
int a = rand(s); // valores inteiros entre o e RAND_MAX

// valores absolutos
int  a = abs(65537);
long la = labs(65537L);
long lla = llabs(65537LL);

// divisão
div_t res = div(31558149,3600); // existem análogos: ldiv e lldiv
printf ("Quociente: %d, resto: %d.\n", res.quot, res.rem);

// string para números C++11
long s = stol("65537");            
       
        

• As linguagens C/C++, Java e Python oferecem bibliotecas nativas para manipulações algébricas e aritméticas.

C/C++ (cmath):

          
// inclusão da biblioteca
#include <cmath>
using namespace std;

// acesso a constantes da biblioteca
#define _USE_MATH_DEFINES

// trigonometria (argumento em radianos)
float s = sin(90.0f * M_PI / 180.0f);

// exponenciais
float a = exp(10);   // e^10
float a = pow(3,10); // 3^10

// logs
float a = log(10);   // base e
float a = log2(10);  // base 2
          
        

• As linguagens C/C++, Java e Python oferecem bibliotecas nativas para manipulações algébricas e aritméticas.

Java (Random e Math):

          
// números aleatórios
import java.util.Random;

Random rand = new Random();
int n = rand.nextInt(50) + 1; // valor no intervalo [1,50]

// matemática
import java.lang.Math;

// trigonometria (argumento em radianos)
float s = Math.sin(90.0 * Math.Pi / 180.0);

// exponenciais
float a = Math.exp(10);   // e^10
float a = Math.pow(3,10); // 3^10

// logs
float a = Math.log(10);   // base e
float a = Math.log2(10);  // base 2
                    
// conversão de / para strings
int a = String.valueOf("735");
string s = Integer.toString(735);
          
        

• As linguagens C/C++, Java e Python oferecem bibliotecas nativas para manipulações algébricas e aritméticas.

Python (random e math):

          
// importação do pacote
import random

n = random.randomInt(1, 50) // valor inteiro no intervalo [1,50]
n = random.random() // valor real no intervalo [0.0,1.0)

// importação do pacote
import math

// trigonometria (argumento em radianos)
s = math.sin(90.0 * math.pi / 180.0);

// exponenciais
a = math.exp(10);   // e^10
a = math.pow(3,10); // 3.0^10.0 
a = 3**10;          // 3^10

// logs
a = math.log(10);   // base e
a = math.log2(10);  // base 2
          
// conversão de / para strings
a = int("735");
s = str(735);          
          
        

• É comum ter que manipular de números inteiros com mais dígitos que os tipos primitivos podem representar.


• Exemplo: o cálculo de 25! (fatorial de 25)
  25! = 15.511.210.043.330.985.984.000.000, isto é um número inteiro de 26 dígitos!


• O que fazer? Usar ou implementar representações de números inteiros grandes!

• A linguagem Java oferece biblioteca nativa para a manipulação de números inteiros com precisão arbitrária.

Java (BigInteger):

          
// números decimais com precisão arbitrária
import java.util.BigInteger;

BigInteger a = BigInteger.valueOf(1250);
BigInteger b = BigInteger.valueOf(5250);

// soma 
BigInteger res = a.add(b);

// multiplicação 
BigInteger res = a.multiply(b);
                   
// quociente (res[0]) e resto (res[1])
BigInteger[] res = a.divideAndRemainder(b)
         
// máximo divisor comum
BigInteger gdc = a.gcd(b)                  
          
        

• A linguagem Python oferece suporte nativo para a manipulação de números inteiros com precisão arbitrária.

Python:

                   
# números inteiros com precisão arbitrária 
# Python oferece suporte nativo
a = 1
b = 3
        
# soma 
res = a + b        

# multiplicação 
res = a * b;
                   
# máximo divisor comum
gdc = math.gcd(a,b)                  
          
        

• A linguagem C/C+ não oferece suporte nativo para a manipulação aritmética de números inteiros com precisão arbitrária.


• Isto é, para ter esta funcionalidade, é preciso implementá-la.


• Você pode implementar uma classe the inteiros grandes usando arrays de inteiros.


• As operações artiméticas precisam ser implementadas.
  Exemplo (soma):

• Alguns problemas exigem a representação de números com mais casas decimais maior que a disponível nos tipos primitivos.


• Em alguns casos, os números manipulados devem ser números racionais exatos.

Assuma que $c = x_1/y_1$ e $d = x_2/y_2$

Soma:
$c + d = \frac{(x_1.y_2 + x_2.y_1)}{y_2.y_1}$

Produto:
$c.d = \frac{x_1.x_2}{y_2.y_1}$

Produto:
$c/d = \frac{x_1.y_2}{x_2.y_1}$

Obs:
Evite denominadores e o numeradores que sejam números inteiros grandes dividindo-os pelo mdc.

Números decimais podem ser convertidos em racionais exatos:

$3.1415 = \frac{3}{1} + \frac{1415}{10000} = \frac{6283}{2000}$

Obs: No caso de dízimas, você deve definir a quantidade de casas decimais que serão consideradas.

$3.14159265359... \approx 3.1415$

$3.1415 = \frac{3}{1} + \frac{1415}{10000} = \frac{6283}{2000}$

• A linguagem Java oferece biblioteca nativa para a manipulação de números decimais com precisão arbitrária.

Java (BigInteger):

          
// números decimais com precisão arbitrária
import java.util.BigDecimal;

BigDecimal a = BigDecimal.valueOf(125.012316526);
BigDecimal b = BigDecimal.valueOf(52.5098967);

// número de dígitos decimais
a.setScale(35, BigDecimal.ROUND_HALF_UP);

// soma 
BigDecimal res = a.add(b);

// subtração 
BigDecimal res = a.add(b);

// multiplicação 
BigDecimal res = a.multiply(b);
                   
// divisão
BigDecimal res = a.divide(b)
          
        

• A linguagem Python oferece biblioteca nativa para a manipulação de números decimais com precisão arbitrária.

Python (decimal):

          
// números decimais com precisão arbitrária
from decimal import *

getcontext().prec = 25  // definição da precisão

a = Decimal('1.2');
b = Decimal('7.3');

// soma 
res = add(a, b);

// multiplicação 
res = multiply(a, b);
                   
// divisão
res = divide(a, b);          
          
        

• A linguagem C/C+ não oferece suporte nativo para a manipulação aritmética de números decimais com precisão arbitrária.


• Isto é, para ter esta funcionalidade, é preciso implementá-la.


• Em uma competição, é recomendável utilizar outras linguagens para resolver problemas que exijam essas funcionalidades.

• É muito importante entender a diferença entre truncamento (floor e ceil) e arrendondamento (round).
  
  $floor(x)$
  
  $ceil(x) = floor(x+1)$
  
  $round(x,k) = \frac{floor(10^kx+0.5)}{10^k}$


• Exemplos:
  $floor(1.2) = 1$, $floor(1.9) = 1$
  $ceil(1.2) = 2$, $ceil(1.9) = 2$
  $round(1.2, 1) = 1$, $round(1.9, 1) = 2$, $round(2.234, 2) = 2.23$

C/C++:

          
// arredondamento e truncamento
int a = floor(10.7);  // 10
int a = ceil(10.7);   // 11

int a = round(10.3);  // 10 --> análogo a floor(10.3)
int a = round(10.7);  // 11 --> análogo a ceil(10.7)
int a = round(80.234 * 100) / 100;  // 83.23
          
        

Java:

          
// arredondamento e truncamento
int a = Math.floor(10.7)   // 10
int a = Math.ceil(10.7)    // 11

int a = Math.round(10.3);  // 10 --> análogo a floor(10.3)
int a = Math.round(10.7);  // 11 --> análogo a ceil(10.7)
int a = Math.round(80.234 * 100) / 100;  // 83.23
        
      

Python:

          
# arredondamento e truncamento
a = math.floor(10.7)   # 10
a = math.ceil(10.7)    # 11

# arredondamento e truncamento
a = round(10.3);     # 10 --> análogo a math.floor(10.3)
a = round(10.7);     # 11 --> análogo a math.ceil(10.7)
a = round(80.234, 2) # 80.23
          
        

Muitos problemas de competição utilizam identidades de logaritmos na elaboração da solução.

Algumas identidades importantes:

• $\log_b(x.y) = \log_b(x) + \log_b(y)$


• $\log_b(x/y) = \log_b(x) - \log_b(y)$


• $\log_b(x^a) = a\log_b(x)$


• $\log_b(x) = \frac{\log_c(x)}{\log_c(b)}$


• $b = x^\frac{1}{\log_b(x)}$

Leitura:

• Capítulo 5 do livro texto Competitive Programming 1
  Halim, S. e Halim, F.

Exercícios:

• Lista de exercícios 07, de problemas Aritmética e Álgebra.