Atividade A1 –

Análise de Algoritmos Iterativos e Notação Assintótica

Data limite de entrega: 14 de outubro

Grupo de 1 a 4 pessoas
Integrantes por ordem de RGM
RGM Nome
Renan da Silva Ferreira 20847327
Felipe José Varollo 20859058
Larissa da Silva Pereira 26243971
1) Considerando o algoritmo abaixo e as operações primitivas estudadas em
sala (atribuição, chamada de função, acesso ao elemento de um arranjo,
operações aritméticas, retorno de função e comparação entre dois
elementos).

módulo Enigma ( inteiro A[], inteiro n )

início
inteiro a, i;
a = 0;
para (i = n - 1; i >= 0; i--) faça
se ((A[i] % 4 = 0) e (A[i] % 5 = 0)) então
a = a + A[i];
fim-se
fim-para
retorna a;
fim.

Pede-se:
a) O que faz o algoritmo enigma?
Resposta: O algoritmo "enigma" verifica se os elementos de A[ ] são divisíveis
por 4 e por 5. Se sim, soma eles na variável a. Retorna todos os elementos de
A[ ] divisíveis por 4 e por 5 somados.

b) Qual a configuração de A para o pior e melhor caso?

Resposta: Melhor caso → Quando A [ ] não possui um número divisível por 4
e por 5.
Pior caso → Quando há um elemento em A[ ] que seja divisível por 4 e por 5.

c) Qual a T(n), em termos de operações primitivas, no melhor caso?

Resposta:
a = 0; 1 + 2 + 1 + 1 = 5 operações
para (i = n - 1; i >= 0; i--) faça primitivas
se ((A[i] % 4 = 0) e (A[i] % 5 = 0))
então
a = a + A[i];
fim-se
fim-para
retorna a;

d) Qual a T(n), em termos de operações primitivas, no pior caso?

Resposta:
a = 0; n−1 n−2

para (i = n - 1; i >= 0; i--) faça 1 + 2 + ∑ ∑ 10 + 1

1 +
i=−1 i=−1
se ((A[i] % 4 = 0) e (A[i] % 5 = 0)) n−1+2 n−2+2
então 4 + ∑ 1+ 10 ∑ 1
a = a + A[i]; i=−1+2
n +1 n
i=−1+2

fim-se 4 + ∑ 1+ 10∑ 1
fim-para i=1 i=1
retorna a; 4 + n+1 + 10n
 5 + n + 10n
11n + 5

e) Qual o  (Theta), no pior caso, por que (Prove pela definição de

Tetha)?
Resposta: f(n) = 11n + 5
= O(?) → 11n + 5 ≤ n
= O(?) → 11n + 5 ≤ 4n

n ≤ 11n + 5 ≤ 4n
portanto, f(n) = Θ(n)

2) Dado o seguinte trecho de código, qual a expressão de k, em função de n ?

 k=0;
 for (i=2; i <= n; i++)
 for (j=n; j >= i; j--)
  k=k+1;
n n n n−(i−1 ) n n−i+ 1 n
Resposta: k = ∑ ❑ ∑ ❑- 1 = ∑❑ ∑ ❑- 1 = ∑ ❑ ∑ ❑- 1 = ∑ ❑n -
i=2 j=i i=2 j=i−(i−1) i=2 j=1 i=2

n n

∑ ❑i + ∑ ❑1
i=1 i=1

= n ∑ ❑1 + n + ½ n(n+1) = 2n² + n - n²/2 - n/2

i=2

4 n ² +2 n−n ²−n
= 2
= (3n² + n)/2 = n(3n + 1)/2

3) Considerando o módulo Enigma abaixo que:

módulo Enigma ( inteiro A[], inteiro n )

início
inteiro a, i;
a ← 0;
para (i ← n - 1; i >= 0; i--) faça
se (A[i] % 2 == 0) então
a ← a + A[i];
fim-se
fim-para
retorna a;
fim.

Pede-se:
a) Qual a funcionalidade do módulo Enigma (o que ele faz)?
Resposta: Retornar a soma da variável a + a posição do vetor que vai ser
definida no for através do inteiro N passado quando o método enigma for
chamado

b) Qual a configuração de A para o pior e melhor caso?

Resposta: Melhor caso: quando o % de a[i] for == 0
Pior caso: quando todos os valores do vetor A forem impares

c) Qual a T(n), em termos de operações primitivas, no pior caso?

Resposta:
a ← 0; 1
para (i ← n - 1; i >= 0; i--) faça n−1 n−2

se ((A[i] % 2 == 0)) então 2+ ∑1+ ∑7+

i=−1 i=−1
a ← a + A[i];
fim-se
fim-para
retorna a;
1
n−1 n−2
T(n) = 1+2+ ∑1+ ∑7+1
i=−1 i=−1

n−1+2 n−2+2
=4+ ∑ 1+ ∑ 7
i=−1+2 i=−1+2

n +1 n
= 4 + ∑1 + ∑7
i=1 i=1

n
= 4 + n + 1 + 7∑ 1
i=1

= 4 + n + 1 + 7n

= 5 + 8n

4) Um determinado algoritmo foi analisado, tendo por base as seis operações

primitivas estudadas em aula, e foi obtido o T(n) na forma de um somatório
abaixo. Pede-se: faça o seu cálculo e obtenha a função T(n) resultante.
n n

T(n) = ∑ ∑ 1
i=1 j=i

Resposta: T(n) = N*n (sabemos que ∑ 1 = N)

j=i

T(n) = N²
5) O trecho de algoritmo para calcular a nn que utiliza uma repetição para a
contagem das multiplicações é dado por:
função inteiro n_elevado_n ( inteiro n) Se n for um múltiplo de 2, como: 1, 2, 4, 8, 16, 32,...
início O algoritmo anterior que calcula nn pode ser reescrito
inteiro res, i; para:
res ← 1;
para (i ← 1; i ≤ n; i++) faça função inteiro n_elevado_n2( inteiro n)
res ← res * n; início
retorna res; inteiro res, i;
fim. res ← n
para (i ← 1; i < n; i= i *2) faça
res ← res * res;
retorna res;
fim.

Considerando todas as operações primitivas estudadas em sala, pede-se:

a) Calcule a equação de complexidade T(n) para n_elevado_n( inteiro n ).

n+1 n
Resposta: T ( n )=1+1+ ∑ 1+ ∑ 3+1=3+n+1+3 n=4 n+ 4
i=1 i=1

b) Calcule a equação de complexidade T(n) para n_elevado_n2( inteiro n ).

n n−1
Resposta:T ( n )=1+1+ ∑ 1+ ∑ 4 +1=3+ n+4 ( n−1 ) =5 n−1
i=1 i=1

c) Determine o O-grande dos dois algoritmos pela definição. Necessário

determinar c e no.
Resposta:
4n + 4 5n - 1

O(n) | n0: 1 | c: 8 O(lg n) | n0: 1 | c: 4

4n + 4, considerando g(n) = n 5n – 1, considerando g(n) = n

4n + 4 ≤ c * n, fazendo c = 8 5n – 1 ≤ c * n, fazendo c = 4

4n + 4 ≤ 8 * n, considerando n0 = 1 5n - 1 ≤ 4 * n, considerando n0 = 1

n = 1 => 4*1 + 4 ≤ 8 * 1 => 8 ≤ 8 n = 1 => 5*1 - 1 ≤ 4 * 1 => 4 ≤ 4

6) Considere os 5 algoritmos abaixo que determinam o enésimo termo da
sequência de Fibonacci.

função inteiro fib_1( int n ) função inteiro fib_2(n)

início início
se (n < 2) retorna n; inteiro a, b, c, d, i = n-1;
senão se (n <= 0) retorna 0;
início (a, b) = (1, 0);
inteiro ant = 1, preant = 1, atual; (c, d) = (0, 1);
para (inteiro i = 3; i <= n; i++) enquanto (i > 0) faça
início início
atual = ant + preant; se (i mod 2 == 0) então
preant = ant; (a, b) = (db + ca, d(b+a) + cd)
ant = atual; (c,d) = (c2 + d2, d (2c + d))
fim i = i div 2;
retorna atual; fim
fim retorna a + b;
fim fim.
função inteiro fib_4( inteiro n )
início
inteiro v[n+1], i = 1;
v[0] = 0;
v[1] = 1;
enquanto (i < n) faça
início
v[i+1] = v[i] + v[i-1];
i = i + 1;
fim
retorna v[n];
fim.

a) Baseado nos estudos realizados em sala, apresente as

complexidades (O-Grande) de cada um dos algoritmos.(Obs.: Não
precisa calcular, basta apresentar o O-Grande)
Resposta: fib_1 e fib_4: O(n) | fib_2: O(lg n)

b) Utilizando o algoritmo fib_4, determine a equação de complexidade

(T(n)) considerando todas as operações primitivas. (Supor que a
declaração "inteiro v[n+1]" contém 2 operações primitivas).
Resposta:10 n−1
n n−1
8+ n+9(n−1)
2+1+2+2+ ∑ 1+ ∑ 9+ 1
i=1 i=1
8+ n+9 n−9
n−1
8+ n+9 ∑ 1 10 n−1
i=1
7) Suponha uma matriz Anxn na qual todos os elementos de cada linha estão
ordenados em ordem crescente e os dois algoritmos abaixo procuram a
existência de um elemento chave dentro das linhas da matriz. Ao encontrar
o elemento chave na linha i insere em um vetor POS a posição (coluna) na
qual o elemento chave foi encontrado dentro da i-ésima linha de A ou -1 se
não achar.
módulo inteiro [] alg_I(inteiro A[][], inteiro n, módulo inteiro [] alg_II(inteiro A[][], inteiro n,
inteiro chave) inteiro chave)
início início
inteiro i, j, POS[]; logica achou;
inteiro i, f, l, m; lógica achou;
para (i 0; i < n; i ++) faça
achou falso; para (i  0; i < n; i ++) faça
para (j 0; ((j < n) e (não achou)); j ++) faça f  0; l  n-1; achou  falso;
se (A[i][j] == chave) então enquanto((f <= l) e ( não achou)) faça
POS[i] j; achou verdadeiro m  (f + l) div 2;
fim-para se (chave == A[i][m]) então
se (não achou) então POS[i] -1;
POS[i]  m; achou  verdadeiro;
fim-para
retorna POS; senão se (chave < A[i][m]) então
fim l  m-1;
senão
f  m + 1;
fim-enquanto
se (não achou) então POS[i]  -1;
fim-para
retorna POS;
fim.

Pede-se:

a) Calcular os tempos T(n) em termos SOMENTE do NÚMERO MÁXIMO DE

COMPARAÇÕES NECESSÁRIAS (pior caso) para encontrar o elemento
chave em cada linha da matriz A para:
n n −1 n+1 n−1+1
4 + ∑ ❑1 + ∑ ❑2 = 4 + ∑ ❑1 + ∑ ❑2 = 4 + n + 1 + 2n = 5 + 3n
i=0 i=0 i=0+1 i=0+1

f(n) = 5 + 3n → O( ? ) = 3n + 5 ≤ n → f(n) = O(n)

b) Qual o O-grande de cada algoritmo. Mostre pela definição de O-grande

encontrando uma constante c e n 0 que os comprove. Sem a demonstração este
item não será avaliado.
n n −1 n+1 n−1+1
5 + ∑ ❑1 + ∑ ❑15 = 5 + ∑ ❑1 + ∑ ❑15 = 5 + n + 1 + 15n = 6 + 16n
i=0 i=0 i=0+1 i=0+1

f(n) = 6 + 15n → O( ? ) = 15n + 6 ≤ n → f(n) = O(n)

a.1) alg_I; e b)

módulo inteiro [] alg_I(inteiro A[][], inteiro n,

inteiro chave)
início
inteiro i, j, POS[]; logica achou;
para (i  0; i < n; i ++) faça
achou  falso;
para (j  0; ((j < n) e (não achou)); j ++) faça
se (A[i][j] == chave) então
POS[i]  j; achou  verdadeiro
fim-para
se (não achou) então POS[i]  -1;
fim-para
retorna POS;
fim

a.2) alg_II; e b)

módulo inteiro [] alg_II(inteiro A[][], inteiro n, .

inteiro chave)
início
inteiro i, f, l, m; lógica achou;
para (i 0; i < n; i ++) faça
f 0; l n-1; achou falso;
enquanto((f <= l) e ( não achou)) faça
m (f + l) div 2;
se (chave == A[i][m]) então
POS[i] m; achou verdadeiro;
senão se (chave < A[i][m]) então
l m-1;
senão
f m + 1;
fim-enquanto
se (não achou) então POS[i] -1;
fim-para
retorna POS;
fim.
c) Baseado no item “a” e “b”, a que conclusão pode-se chegar?

8) Considerando o algoritmo e as operações primitivas estudadas em sala

(atribuição, chamada de função, acesso ao elemento de um arranjo,
operações aritméticas, retorno de função e comparação entre dois
elementos).
função inteiro produto(inteiro n, inteiro m)
início
inteiro r;
r  0;
enquanto ( n  0) faça
início
se (n mod 2  0) então
início
r  r + m;
fim
n  n div 2;
m  m * 2;
fim
retorna r;
fim

Pede-se:
a) Quais possíveis valores de n no pior caso e melhor caso?
melhor caso → n = 0
pior caso → n ≠ 0

b) Qual a T(n), em termos de operações primitivas, no pior caso?

T(n no pior caso) = 1 + (log n + 1) + log n . 8 + 1 = 9 log n + 3 op.
primitivas

c) Qual o  (Theta), por quê?

f(n) = 9 log n + 3 = 9 . 2^n + 2 = O(2^n)
9) (Análise de Algoritmos Iterativos - Baseada no ENADE) No cálculo da
potência de n elevado a n ( nn ), onde n pertence a N, é possível elaborar
diferentes algoritmos. Em particular, pode-se pensar em soluções
algorítmicas que calculam a potência para valores de n múltiplos de 2, tais
como: 1, 2, 4, 8, 16, 32,... Duas soluções algorítmicas que calculam a
potência para valores de n múltiplos de 2 são apresentados a seguir.

Algoritmo 1:

função inteiro n_elevado_n ( inteiro n )

início
inteiro res, i;
res ← 1;
para (i ← 1; i ≤ n; i++) faça
res ← res * n;
retorna res;
fim.

Algoritmo 2:

função inteiro n_elevado_n2( inteiro n )

início
inteiro res, i;
res ← n
para (i ← 1; i < n; i= i * 2) faça
res ← res * res;
retorna res;
fim.

Com base nos algoritmos 1 e 2, avalie as asserções a seguir e a relação

proposta entre elas.
I - O Algoritmo 1 é mais eficiente que o Algoritmo 2 em termos do tempo
de execução.
PORQUÊ
II - A complexidade assintótica do Algoritmo 1 é O(n log n) e do
Algoritmo 2 é O( n ).
A respeito dessas asserções, assinale a alternativa correta.
A) As asserções I e II são proposições verdadeiras, e a II é justificativa
correta da I.
B) As asserções I e II são proposições verdadeiras, mas a II não é uma
justificativa correta da I.
C) A asserção I é uma proposição verdadeira, e a II é uma proposição
falsa.
D) A asserção I é uma proposição falsa, e a II é uma proposição
verdadeira.
E) As asserções I e II são proposições falsas.
Resposta: E) As asserções I e II são proposições falsas.

10)Um algoritmo de complexidade 8 * log 2 n. Num certo computador, num

tempo t, o algoritmo resolve um problema de tamanho 16 dados. Imagine
agora que você tem disponível um computador 2 vezes mais rápido. Qual o
tamanho máximo de problema que o mesmo algoritmo resolve no mesmo
tempo t no computador mais rápido.

Resposta: 8 * log2n ---------------------------- 16

2(8*log2n)
16* 2 * log2n
32*log2n ----------------------------- x

8*log2nx = 32*log2n*16
X= 512 log2n / 8 log2n
X = 64

11)Um certo professor criou um programa para levantar estatísticas sobre o

desempenho de seus alunos. A eficiência do programa é medida pelo
número de comparações feitas no processamento e é expressa pela função
A(n) = n² + 500 – lg lg n, onde n é o número de alunos da turma. A direção
da escola aprovou o uso do programa e resolveu aplicá-lo para todos os
alunos. Outro professor gostou da ideia e resolveu criar o seu próprio
programa com eficiência medida por B(n) = 60n - lg lg n. Agora é necessário
saber qual dos dois programas será utilizado. De modo a auxiliar a direção
da escola na tomada de decisão, calcule e determine qual valor de n  N a
função A(n) é mais eficiente que B(n):

Justificativa: N²+500-lg.lg.n < 60N-lg.lg.n

N²+500-lg.lg.n-60N+lg.lg.n<0
N²-60N+500<0

DELTA = (-60)² -4.(1).(500)

3600-2000
1600

N= -(-60) +/- raiz(1600)

_____________________
2.(1)

N1= (60+40)/2 = 50

N2= (60-40)/2 = 10

Resposta = 10 =< N =< 50 pertence aos naturais.

12)Um algoritmo é executado em 5 segundos para uma entrada de tamanho
100. Se o algoritmo tem tempo de execução dado por T(n)=K n log n,
quanto tempo em segundos, aproximadamente, ele levará, no mesmo
computador, para uma entrada de tamanho 1000?

Resposta: N-T(s)
100-5(s)
1000-X(s)
X=(1000.5)/100
X=50(s)

13)Dois algoritmos A e B tem a função de complexidade de tempo A(n) =n 2 +

500 + lg n e B(n) = 60n + lg n. Pergunta-se: Para quais n  N, A(n) é mais
eficiente que B(n)?

Resposta: N²+500+lg n < 60N+lg n

N² + 500 + lg n – 60n - lg n < 0
N² + 500 – 60n< 0
DELTA = (-60)² -4.(1).(500)
3600-2000
1600

N= -(-60) +/- raiz(1600)

_____________________
2.(1)

N1= (60+40)/2 = 50

N2= (60-40)/2 = 10

Resposta = 10 =< N =< 50 pertence aos naturais.

14)Um algoritmo de complexidade 4* lg n. Num certo computador, num tempo

t, o algoritmo resolve um problema de tamanho 32. Imagine agora que você
tem disponível um computador 2 vezes mais rápido. Qual o tamanho
máximo do problema que o mesmo algoritmo resolve no mesmo tempo t no
computador mais rápido.

Resposta: Resolveria um problema com o dobro de tamanho (64).

4.lg.n --- 32
2(4.lg.n) --- X
X = 64
15)Dois algoritmos A e B com complexidade A(n) =n2 + 500 - lg lg n e B(n) =
60n - lg lg n. Pergunta-se: Para quais n  N, A(n) é mais eficiente que
B(n)?

Resposta: A(n) < B(n)

N2 + 500 - lg lg n < 60n – lg lg n

N2 + 500 – lg lg n + lg lg n – 60n < 0
N2 - 60n +500 < 0

DELTA = - 602 – 4(1)(500)

DELTA = 3600 – 2000
DELTA = 1600

N = (-(-60) +/- √1600)/ 2(1)

N1= (60+40)/2 = 100/2 = 50
N2= (60-40)/2 = 20/2 = 10 10 50

Portanto, A(n) < B(n) quando n >= 10 e n =<50, n ∈ N.

16)(Baseada nas questões do POSCOMP 2002 e 2004). Com base nos

estudos sobre Notação Assintótica, determine quais das seguintes
igualdades ou afirmações são verdadeiras.

I. A propriedade transitividade é válida somente para as notações

Θ ,O e Ω, mas não são válidas para as notações o e ω.
II. f(n) = O(g(n)) se e somente se g(n) = ω (f(n))
III. log 10 n+n=Ω(log 10 n)
IV. 2n+ 3=O(2n )
V. √ n3 + log10 n=Ο( n)
A) somente II e IV
B) somente I e III
C) somente I e IV
D) somente I, II e V
E) somente III e IV

Resposta: E) somente III e IV

17)Escrever se as afirmações abaixo são verdadeiras ou falsas?

Explicar o porquê em cada caso.

a) log 2 n+ √ n=O(log 2 n)
n + √n = O(n)
n + log n = O(n)

falso, log n pode ser 2^n = x, mudando o O(n) para O(2^n)

b) 3n +2=Θ(3n )
3^n+2 = Θ (3^n)
3^n . 3^2 = Θ (3^n)

verdadeiro, 3^n ≤3^n . 3^2 ≤3 . 3^n

c) 1000n2 + nlog 2 n2=Ω(n2 )

1000 n^2 + n . n^2 = Ω (n^2)
1000 n^2 + n^3 = Ω (n^2)

falso, 1000 n^2 + n^3 ≥n^3, então Ω (n^3)

d) f(n) = (g(n)) se e somente se g(n) = O(f(n))

verdadeiro, g(n) = O(ω(g(n))), O de g(n) = g(n)

e) n3 + n3 log2 n2 = o(n4)
n^3 + n^3 log n^2 = O(n^4)
2n^3 . 2^n^2 = O(n^4)

falso, O(n^3)
18)Quais das seguintes igualdades ou afirmações NÃO são verdadeiras?
Explicar o porquê em cada caso.

I. A propriedade transitividade é válida somente para as notações

Θ ,O e Ω, mas não são válidas para as notações o e ω.

II. f(n) = O(g(n)) se e somente se g(n) = ω (f(n))

III. log 10 n+n=Ω(log 10 n)

IV. 2n+ 3=O(2n )

V. √ n3 + log10 n=Ο( n)

Apenas as afirmações I e II são falsas:

I. Propriedade transitividade é válida apenas para Θ, Ω, o e ω. Não é

válida para o O.
II. A propriedade seria verdadeira se invés de O(g(n)), fosse o(g(n)).

19)(Baseada em questão do POSCOMP 2016). Um algoritmo que trabalha

com uma matriz A contendo n linha e m colunas tem complexidade
O(100m4 + 10m2n2 + 200mn2 + 800n2 + 90m2 ). Considerando as
propriedades do O-Grande, apresente uma maneira simplificada de
expressar a complexidade desse algoritmo.
A) O(m4 ).
B) O(m2 ).
C) O(m4 + m2n2 ).
D) O(m2n2 ).
E) O(m4+ n2 ).

Resposta: C) O(m4 + m2n2)

20) Sabendo-se que a função de complexidade obtida para um algoritmo no
pior caso foi T(n) = 12n + 4. Determine o  (Theta) pela definição, ou seja,
encontre c1, c2, n0 e a g(n).

Resposta: c1: 1 | c2: 16 | n0: 1 | g(n): n

f(n) = 12n + 4 é (?), fazendo g(n) = n

12n + 4 ≥ c n para todo n ≥ n0, considerar c = 1

12n + 4 ≥ n para todo n ≥ n0, considerar n0 = 1

N = 1 => 12*1 + 4 ≥ 1 => 16 ≥ 1

f(n) = 12n + 4 é  (?), fazendo g(n) = n

c1 * n ≤ 12n + 4 ≤ c2 * n para todo n ≥ n0, considerar c1 = 1 e c2 = 16

1 * n ≤ 12n + 4 ≤ 16 * n para todo n ≥ n0, supondo n0 = 1

n = 1 => 1 * 1 ≤ 12*1 + 4 ≤ 16 * 1 => 1 ≤ 16 ≤ 16

21) Qual o  (n) para t(n) = n2 - n - 2 ? Mostre pela definição de , encontrando

as constantes, c1, c2 e n0.
Resposta: Então fica provado que T(n) é θ(n²) e C1 = -2 e C2 = 4
Supondo g(n) = n, pela definição temos:

F(n) ≥ cg(n) para todo n ≥ n0

n2 - n – 2 ≥ c n² para todo n ≥ n0, considerar constante c = -2

n2 - n – 2 ≥ -2 * n² para todo n ≥ n0, considerando n0 = 1
n2 - n – 2 ≥ -2 * n² para todo n ≥ n0
n=1 => 12 - 1 – 2 ≥ -2 * 1² => -2 ≥ - 2
n=2 => 2² - 2 – 2 ≥ -2 * 2² => 0 ≥ - 8
n=3 => 3² - 3 – 2 ≥ -2 * 3³ => 4 ≥ - 18

sendo assim fica demonstrado pelo Ω que t(n) é O(n²)

Agora encontraremos o θ t(n)

T(n) = n² - n -2 é θ( ? ), fazendo g(n) = n²

Usando a definição de θ temos:
C1g(n) ≤ f(n) ≤ c2g(n) para todo n ≥ n0
C1* n² ≤ n² - n -2 ≤ c2 * n² para todo n ≥ n0,
sabemos pela def. acima que c1 = -2 e c2 sendo a soma dos coeficientes = 4

-2 * n² ≤ n² - n -2 ≤ 4 * n² para todo n ≥ n0, supondo n0 = 1

N = 1 => -2 * 1² ≤ 1² - 1 -2 ≤ 4 * 1² => -2 ≤ -2 ≤ 4

N = 2 => -2 * 2² ≤ 2² - 2 -2 ≤ 4 * 2² => -8 ≤ 0 ≤ 16

N = 3 => -2 * 3² ≤ 3² - 3 -2 ≤ 4 * 3² => -18 ≤ 4 ≤ 36

Então fica provado que T(n) é θ(n²) e C1 = -2 e C2 = 4

22) Considere T(n) = T(n) = 8n - 8, encontre o O-Grande para a função T(n)

pela definição?.
Resposta: T(n) = 8n – 8 é O(8n)

Considerando g(n) = 8n (termo de maior crescimento)

Considerando a definição de O grande: Dada duas funções positivas f(n) e

g(n), f(n) é O(g(n)) se existem números positivos c e n0 tais que

f(n) <= cg(n) para todo n>=n0

8n – 8 ≤ c 8n para todo n ≥ n0 (encontrar C e N0)
Somando os coeficientes temos 16
8n – 8 ≤ 16*8n para todo n ≥ n0 (encontrar N0)
Considerando o n0 = 1, 2 e 3
8(1) – 8 ≤ 16*8(1) para todo n ≥ 1

N=1 => 8(1) – 8 ≤ 16*8(1) = 8 ≤ 128 (Verdadeiro)

N=2 => 8(2) – 8 ≤ 16*8(2) = 8 ≤ 256 (Verdadeiro)
N=2 => 8(3) – 8 ≤ 16*8(3) = 16 ≤ 384 (Verdadeiro)
Logo T(n) = 8n – 8 é O(8n)

23) Sejam as funções f(n) = (lg n) 3 + n e g(n) = n + n 2 lg n. Compará-las e dizer

se f(n) = O(g(n)), f(n)=Ω(g(n)) e/ou f(n) = Θ(g(n)), f(n) = o(g(n)) ou f(n) =
w(g(n)).

Resposta: g(n) = n + n^2 log n = O(n) + O(n^2 . n) = O(n) + O(n^3) = O(n^3)

f(n) = (log n)^3 + n = n^3 + n = O(n^3) + O(n) = O(n^3)

Por esse fato, f(n) é O(g(n)), f(n) é Ω(g(n)) e f(n) = Θ(g(n))

24) Sejam as funções f(n) = (lg n) 3 + n2 lg n e g(n) = n2 + n lg n. Compará-las e

dizer se f(n) = O(g(n)), f(n)=Ω(g(n)) e/ou f(n) = Θ(g(n)), f(n) = o(g(n)) ou f(n)
= w(g(n)).
Resposta: g(n) = n^2 + n log n = O(n^2) + O(n^2) = O(n^2)

f(n) = (log n)^3 + n = n^3 + n = O(n^3) + O(n) = O(n^3)

Por esse fato, f(n) é Ω(g(n)) e f(n) = (g(n))