---
# System prepended metadata

title: '#Back-end - A10-11 - 28/07'
tags: [Back-end]

---

# #Back-end - A10-11 - 28/07

##### Aluno: Pedro Ciccone
###### tags: `Back-end`

### Exercícios aula

**0.** Para o dataset de `times_dataset`, busque:

**A.** Pelas categorias que tiveram mais honras, liste as 5 mais honradas.
```
select
    category, count(*)
from times
group by
    category
order by
    count desc
    limit 5;
```
**B.** Busque pelas categorias que tiveram entre 3 e 6 honras.
```
select *
from (
	select category, count(*)
	from times
	group by category
	order by count desc
) as honras
where count between 3 and 6;
```
**C.** Com os dados da resposta anterior, busque as honras que sejam as duas mais premiadas (baseando na resposta anterior).
```
select name, category, year
from times
where category in (
	select category from (
			select category, count(*)
			from times
			group by category
			order by count desc
	) as honras
	where count between 3 and 6
	order by count desc 
	limit 2
);
```

**1.**  No dataset de `nobel`, busque por:

**A.** Para os países que mais tiveram honras (assume-se o país de nascimento), busque por aqueles que tiveram entre 10 e 50 honras. Dica: Subquery no `FROM`;
```
select *
from (
	select birth_country, count(*)
	from nobel
	group by birth_country
	order by count desc) as award
where count between 10 and 50;
```
**B.** Existem divisões no prêmio, a coluna `prize_share` refere-se à divisão, ex: 1/1 significa que o prêmio não foi dividido, 1/2 significa que duas pessoas dividiram a premiação, 1/3 significa 3 pessoas, e 1/4, 4 pessoas. Quais divisões são as menos comuns?

Resposta: as menos comuns são as divisões entre 4 pessoas.
```
select
    prize_share, count(*)
from nobel
group by
    prize_share
order by
    count asc;
```
**C.** Utilizando a consulta da resposta anterior como base, busque por todas as premiações que entram na restrição de ser a menos comum em relação a divisão. Utilize subqueries para responder essa pergunta!
```
select *
from nobel
where prize_share = (
	select prize_share
	from nobel
	group by prize_share
	order by count(*) asc
	limit 1
	);
```
**D.** Com base nos resultados da **1.C**, obtenha a quantidade de premiações por categoria. Ordene-as por quantidade de premiações.
```
select
    category, count(*)
from nobel
where prize_share = (
	select prize_share
	from nobel
	group by prize_share
	order by count(*) asc
	limit 1
	)
group by
    category
order by
    count desc;
```
**E.** Utilizando a consulta da resposta anterior como base, busque pela categoria que obteve acima de 30 honras. Utilize subquery para responder essa pergunta!
```
select *
from (
	select category, count(*) from nobel
	where prize_share = (
		select prize_share
		from nobel
		group by prize_share
		order by count(*) asc
		limit 1
		)
	group by category
	order by count desc
) as amount
where
	count > 30;
```
**2.** Nos datasets de `cervejas` e `cervejarias`, busque por:

**A.** Quais palavras mais comuns para nomes de cervejarias? Liste as mais comuns e limite a quantidade em 4 itens.
```
select distinct
	unnest (string_to_array (name, ' ')) as nomes,
	count(name)
from cervejarias
group by
	nomes
order by
	count desc
	limit 4;
```
**B.** Quais palavras mais comuns para nomes de cervejas? Liste as mais comuns e limite a quantidade em 5 itens.
```
select distinct
	unnest (string_to_array (name, ' ')) as nomes,
	count(name)
from cervejas
group by
	nomes
order by
	count desc
	limit 5;
```
**C.** Agora, busque pelas palavras menos comuns para os nomes de cervejarias, aquelas que são utilizadas apenas uma vez. Qual a quantidade de palavras que são usadas apenas uma vez?
```
select count(*) from 
	(select nome, count(*) from
		(select unnest (string_to_array (name, ' ')) as nome
		from cervejarias
		) as menos_usadas
		group by nome 
		order by count(*) desc
	) as cervejarias_qtd
where count = 1;
```
**D.** Agora, ao invés de cervejarias, busque por palavras menos utilizadas para cervejas, aquelas que são utilizadas apenas uma vez. Qual a quantidade de palavras que são usadas apenas uma vez?
```
select count(*) from 
	(select nome, count(*) from
		(select unnest (string_to_array (name, ' ')) as nome
		from cervejas
		) as menos_usadas
		group by nome 
		order by count(*) desc
	) as cervejas_qtd
where count = 1;
```
**E.** Busque por todas as palavras que apareçam tanto em nome de cervejarias quanto em nome de cervejas, qual a quantidade de palavras que entram nessa condição? Dica: Interseção!
```
select count(cervejas.nome) from (
	select unnest (string_to_array (name, ' ')) as nome, count(*)
	from cervejas
	group by nome 
	order by count(*) desc
) as cervejas
inner join
(select * from (
	select unnest (string_to_array (name, ' ')) as nome, count(*)
	from cervejarias
	group by nome 
	order by count(*) desc) as cervejarias
	) as cervejarias
on cervejas.nome = cervejarias.nome
; = cervejarias.nome
group by nome;
```
**3.** No dataset do `netflix`, busque por:

**A.** A lista de todos atores ou atrizes que participaram de alguma produção.
```
select distinct unnest(string_to_array(casting, ', '))
from netflix;
```
**B.** Depois, encontre a quantidade de participações que cada um desses atores e atrizes tiveram.
```
select
	unnest(string_to_array(casting, ', ')) as actors,
	count(*)
from netflix
group by actors
order by count desc;
```
**C.** Depois, busque os/as 10 que mais tiveram participações.
```
select
	unnest(string_to_array(casting, ', ')) as actors,
	count(*)
from netflix
group by actors
order by
	count desc
	limit 10;
```
**D.** Desconsiderando o exercício anterior (**3.C**), para a lista de todos os atores e atrizes e suas participações, busque por aqueles que tiveram entre 10 e 30 participações, mas não aqueles que tiveram entre 15 e 20 participações.
```
select * from (
	select
		unnest(string_to_array(casting, ', ')) as actors,
		count(*)
	from netflix
	group by actors
	order by
		count desc
) as participacoes
where
	count between 10 and 30
	and not count between 15 and 20
;
```
**E.** Com base na lista de todos os atores e atrizes e suas participações, busque por aqueles que tiveram 10 ou mais participações em produções de países exclusivos (somente um país participou da produção) e que não atuaram em filmes indianos (India).
```
select * from (
	select
		unnest(string_to_array(casting, ', ')) as actors,
		country,
		count(*)
	from netflix
	where
		country <> '%,%'
		and country <> 'India'
	group by actors, country
	order by
		count desc
	) as participacoes
	where count >= 10
;
```
**F.** Quais atores ou atrizes atuaram também como diretores em alguma produção? Após encontrar as informações, ordene-as em ordem alfabética. Dica: JOIN!
```
select actors.nome from
	(select distinct
	unnest(string_to_array (casting, ', ')) as nome
	from netflix) as actors
inner join
	(select distinct
	unnest(string_to_array (director, ', ')) as nome
	from netflix) as directors 
on actors.nome = directors.nome
order by actors.nome asc
;
```
**4.** No dataset do `netflix`, busque por:

**A.** A lista das produções realizadas por países exclusivos (apenas um país participou da produção).
```
select distinct
	title,
	unnest(string_to_array(country, ', ')) as country
from netflix
order by
	title asc;
```
**B.** As palavras mais comuns nos títulos para todas as produções de países exclusivos, ordenando-as pela quantidade. Não se preocupe com pontuações (`:`, `,`, `!`) no título.
```
select
	unnest(string_to_array(title, ' ')) as palavras,
	count(*)
from netflix
where
	country not like '%,%'
group by palavras
order by count desc
;
```
**C.** Utilizando a query anterior como base, busque por palavras que foram utilizadas entre 20 e 40 vezes.
```
select * from (
	select unnest(string_to_array(title, ' ')) as palavras,
		count(*)
	from netflix
	where
		country not like '%,%'
	group by palavras
	order by count desc
	) as contagem
where
	count between 20 and 40
;
```
**D.** A partir da questão **4.B**, encontre a oitava palavra mais utilizada em títulos.
```
select contagem.palavras from (
	select
		unnest(string_to_array(title, ' ')) as palavras,
		count(*)
	from netflix
	where
		country not like '%,%'
	group by palavras
	order by count desc
	) as contagem
offset 7
limit 1
;
```