---
# System prepended metadata

title: Final Session | Fundamentos da Lógica

---

# Final Session | Fundamentos da Lógica
**Autor**: Vitório Trindade Santana
**Turma**: Informática C
**Número**: 50

[toc]

## Nível 1

### Exercício 1 
Faça uma função ÚNICA que a partir da base e altura, calcule a área do triângulo.

```csharp=
public double AreaTriangulo (double areaT, double baseT)
{
        double calc = areaT * baseT;
        double calc2 = calc / 2;
        return calc2;
}
double n1q1 = AreaTriangulo (2, 5);
//5
```

### Exercício 2
Faça uma função ÚNICA que a partir do lado, calcule o perímetro do octógono.

```csharp=
public int PerimetroOctogono (int lado)
{
	int calculo = lado * 8;
	return calculo;
}
int n1q2 = PerimetroOctogono (9);
//72
```

### Exercício 3
Faça uma função ÚNICA que a partir da base maior, base menor e altura, calcule a área do trapézio.

```csharp=
public int CalculoAreaTrapezio (int bmenor, int bmaior, int altura)
{
	int calculo = ((bmenor + bmaior) * altura) / 2;
	return calculo;
}
int n1q3 = CalculoAreaTrapezio (3, 4, 8);
//28
```


### Exercício 4
Faça uma função ÚNICA que a partir da diagonal maior e menor, calcule a área do losango.

```csharp=
public int CalculoAreaLosango (int diagonalmenor, int diagonalmaior)
{
	return (diagonalmenor * diagonalmaior) / 2;
}
int n1q4 = CalculoAreaLosango (4, 10);
//20
```

## Nível 2

### Exercício 2
Faça uma função ÚNICA que a partir de um peso e altura de uma pessoa, calcule o IMC. Arredonde a resposta para duas casas decimais.

```csharp=
public double CalculoImc (double peso, double altura)
{
	double altura2 = Math.Pow(altura, 2);
	double calcimc = peso / altura2;
	double calcimc2 = Math.Round(calcimc, 2);
	return calcimc2;
}
double n2q2 = CalculoImc (68, 1.76);
//21.95
```

### Exercício 3
Faça uma função ÚNICA que a partir de um capital, parcelas e taxa de juros, calcule o juros compostos. Arredonde a resposta para uma casa decimal.

```csharp=
public double CalculoJurosComposto (double capital, int parcelas, double juros)
{
	double taxa = 1 + juros / 100;
	double taxa2 = Math.Pow(taxa, parcelas);
	double montante = capital * taxa2;
	double montante2 = Math.Round(montante, 2);
	return montante2;
}
double n2q3 = CalculoJurosComposto (19000, 7, 2);
//21825.02
```

### Exercício 4
Faça uma função ÚNICA que a partir da massa e velocidade, calcule a energia cinética. Obrigatório o uso da função Math.Pow.

```csharp=
public double CalculoEnergiaCinetica (double massa, double velocidade)
{
	double velocidade2 = Math.Pow(velocidade, 2);
	double calculoenergia = (massa * velocidade2) / 2;
	return calculoenergia;
}

double n2q4 = CalculoEnergiaCinetica (10, 3);
//45
```

### Exercício 5
Faça uma função ÚNICA que a partir da altura e raio, calcule o volume de um cilindro. Obrigatório o uso da função Math.Pow.

```csharp=
public double VolumeCilindro (double altura, double raio)
{
        double raioc = Math.Pow (raio, 2);
        double calcvolume = 3.14 * raioc * altura;
        return calcvolume;
}
double n2q5 = VolumeCilindro(4, 2);
//50.24
```

## Nível 3

### Exercício 1
Faça uma função ÚNICA que a partir de um nome completo de uma pessoa, extraia o primeiro nome.

```csharp=
public string PrimeiroNome (string nome, string sobrenome, string ultimonome)
{
	string completo = nome + sobrenome + ultimonome;
	int tamanho = nome.Length;
	string recorte = completo.Substring(0, tamanho);
	return recorte;
}
string n3q1 = PrimeiroNome ("Gabriel ", "Silva ", "Santos");
//Gabriel
```

### Exercício 2 
Faça uma função ÚNICA que a partir de um nome completo de uma pessoa, extraia o último nome.

```csharp=
public string UltimoNome (string nome, string sobrenome, string ultimonome)
{
	string completo = nome + sobrenome + ultimonome;
	int posicao = completo.LastIndexOf(" ");
	int tamanho = ultimonome.Length;
	string recorte = completo.Substring(posicao + 1, tamanho);
	return recorte;
}
string n3q2 = UltimoNome ("Ednaldo ", "Pereira ", "Santos");
//Santos
```

### Exercício 3 
Faça uma função ÚNICA que a partir de um e-mail de uma pessoa, extraia o domínio do e-mail.

```csharp=
public string DominioEmail (string email)
{
	int posicao = email.IndexOf("@");
	return email.Substring(posicao, 10);
}
string n3q3 = DominioEmail ("garbmil10@gmail.com");
//@gmail.com
```

### Exercício 4 
Faça uma função ÚNICA que a partir de um CEP, retorne verdadeiro/falso se o CEP contém o caractere hífen (-) e possui um total de 9 caracteres.

```csharp=
public bool VerificarCep (string cep)
{
	bool verificacao = cep.Contains("-") && cep.Length == 9;
	return verificacao;
}
bool n3q4 = VerificarCep ("25789-987");
//true
```

## Nível 4

### Exercício 1
Faça uma função ÚNICA que a partir de uma data, descubra o último dia do mês a partir dessa data.
```csharp=
public DateTime PrimeiroDia (DateTime data)
{
	DateTime a = new DateTime(data.Year, data.Month, 1);
	DateTime b = a.AddMonths(1);
	return b;
} 

DateTime x = DateTime.Now;
DateTime n4q2 = PrimeiroDia (x);
// 5/1/2021
```


### Exercício 3
Faça uma função ÚNICA que a partir de uma data, retorne verdadeiro/falso se a data pertence ao segundo trimestre do ano.
```csharp=
public bool SegundoTrimestre (DateTime data)
{
	int mes = data.Month;
	bool sera = mes >= 4 && mes <= 6;
	return sera;
}
DateTime d = new DateTime(2021, 04, 16);
bool n4q3 = SegundoTrimestre (d);
//true
```

### Exercício 4 
Faça uma função ÚNICA que a partir de uma data, retorne verdadeiro/falso se a pessoa tem mais de 18 anos a partir do dia atual.
```csharp=
public bool VerificarMaiordeIdade (DateTime nascimento)
{
	DateTime a = DateTime.Now;
	DateTime b = a.AddYears(-18);
	bool confere = nascimento <= b;
	return confere;
}
DateTime minhadata = new DateTime(2004, 12, 26);
bool sera = VerificarMaiordeIdade (minhadata);
//false
```
### Exercício 5
Faça uma função ÚNICA que a partir de uma data, retorne verdadeiro/falso se a data pertence a primeira quinzena do mês.
```csharp=
public bool PrimeiraQuinzenaDoMes (DateTime data)
{
	int a = data.Day;
	bool verificar = a >= 1 && 15 >= a;
	return verificar;
}
DateTime b = DateTime.Now;
bool n4q5 = PrimeiraQuinzenaDoMes (b);
//false
```

## Nível 5

### Exercício 1 
Faça uma função COMPOSTA que a partir dos valores 'a', 'b' e 'c’, calcule o valor de 'x’ baseado na equação de segundo grau.

```csharp=
public double CalculoEquacao2Grau (double a ,double b , double c)
{
	double b2 = Math.Pow(b, 2);
	double equacao = EquacaoDo2Grau (a , c);
	double x = b2 + equacao;
	return x;
}
public double EquacaoDo2Grau (double a, double c )
{
	double x =  -4 * a * c;
	return x ;
}
double n5q1 = CalculoEquacao2Grau (1, -4, -12);
//64
//obs = Se colocar o sinal de subtração na double x da função CalculoEquacao2Grau o cálculo fica errado porque a máquina vai somar o sinal de subtração e o que veio na variavel equacao.
```

### Exercício 2 
Faça uma função COMPOSTA que encontre um termo de uma PA
(Progressão Aritmética), a partir do primeiro termo, razão e posição do termo que deseja encontrar.

```csharp=
public int CalculoPA (int a1, int razao, int an)
{
	int n =  InicioCalculoPa (razao, an);
	int calculofinal =  a1 + n;
	return calculofinal;
}

public int InicioCalculoPa (int razao, int an)
{
	return (an -1) * razao;
}

int n5q2 = CalculoPA (5, 5, 25);
//125
```

### Exercício 3
Faça uma função COMPOSTA que encontre um termo de uma PG
(Progressão Geométrica), a partir do primeiro termo, razão e posição do termo que deseja encontrar.

```csharp=
public double CalculoPG (int a1, int razao, int an)
{
	double An = InicioCalculoPg (razao, an);
	double finalcalculo = a1 * An;
	return finalcalculo;
}

public double InicioCalculoPg (int razao, int an)
{
	double razao2 = Math.Pow(razao, an - 1);
	return razao2;
}

double n5q3 = CalculoPG (3, 4, 5);
//768
```

### Exercício 4
Faça uma função COMPOSTA que a partir de dois nomes completos, retorne verdadeiro/falso se as pessoas são da mesma família, comparando o último nome das duas pessoas.

```csharp=
public bool ConferirParentesco (string nome1, string sobrenome1, string ultimonome1, string nome2, string sobrenome2, string ultimonome2)
{
	string nomec1 = NomeCompleto1 (nome1, sobrenome1, ultimonome1);
	string nomec2 = NomeCompleto2 (nome2, sobrenome2, ultimonome2);
	bool confere = nomec1 == nomec2;
	return confere;
}

public string NomeCompleto1 (string nome1, string sobrenome1, string ultimonome1)
{
	string nome = nome1 + sobrenome1 + ultimonome1;
	int posicao1 = nome.LastIndexOf(" ");
	int tamanho = ultimonome1.Length;
	string nomef = nome.Substring(posicao1, tamanho);
	return nomef;
}

public string NomeCompleto2 (string nome2, string sobrenome2, string ultimonome2)
{
	string nome = nome2 + sobrenome2 + ultimonome2;
	int posicao = nome.LastIndexOf(" ");
	int tamanho = ultimonome2.Length;
	string nomef = nome.Substring(posicao, tamanho);
	return nomef;
}
bool n5q4 = ConferirParentesco ("Gustavo ", "Henrique ", "Silveira", "João ", "Guilherme ", "Silva");
//false
```