---
# System prepended metadata

title: Final Session || Fundamentos da Lógica

---

# Final Session || Fundamentos da Lógica
Author: Rafaela de Deus dos Santos Nascimento
Turma: INFOD
Número: 42

[TOC]

## Nível 1
### Exercício 1
Faça uma ÚNICA que a partir da base e altura, calcule a área do triângulo.
```csharp=
public double areatriangulo(double altura, double basee)
{
    double area = (altura * basee) / 2;
    return area;
}

double x = areatriangulo(10, 5);
x
// 25
```

### Exercício 2
Faça uma função ÚNICA que a partir do lado, calcule o perímetro do
octógono.
```csharp=
public perimetrooctagono (int lado)
{
    int perimetro = lado * 4;
    return perimetro;
}

int total = perimetrooctagono (8);
total
//32
```

### 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 areatrapezio (int basemaior, int basemenor, int altura)
{
	int totaltrapezio = (basemaior * basemenor) * altura / 2;
	return totaltrapezio;
}

int x = areatrapezio (10, 4, 5);
x
//100
```

### 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 arealosango (int diagonalmaior, int diagonalmenor)
{
	int total = (diagonalmaior * diagonalmenor) / 2;
	return total;
}

int x = arealosango (10, 5);
x
//25
```

## Nível 2
### Exercício 1
Faça uma função ÚNICA que a partir do cateto oposto e adjacente, calcule
a hipotenusa. Arredonde a resposta para uma casa decimal.
```csharp=
public double calcularhipotenusa (double h, double catetooposto, double catetoadjascente)
{
	double total = catetooposto * catetooposto + (catetoadjascente * catetoadjascente);
	double arredondar = Math.Round(h, 2);
	return arredondar;
}

double x = calcularhipotenusa (8.9, 4.8, 10.6);
x
//8.9
```
### 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 calcularimc (double peso, double altura)
{
	double total = peso / (altura * altura) ;
	double arredondar = Math.Round(total, 2);
	return arredondar;
}

double x = calcularimc (80, 1.80);
x
//29.69
```

### Exercício 3

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 energiacinetica (double massa, double velocidade)
{
	double total = massa * Math.Pow (velocidade, 2) / 2;;
	return total;
}

double x = energiacinetica (1000, 3);
x
//4500
```
### Exercício 4
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 raio, double altura)
{
	double total = 3.1 * Math.Pow(raio,2) * altura;
	return total;
}

double v = volumecilindro (4, 5);
v
//248
```
## 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 nomesobrenome (string nome, string sobrenome)
{
	string nmc = nome + sobrenome;
	string novo = nmc.Substring(7);
	return novo;		
}

string recorte = nomesobrenome ("Rafaela", "Nascimento");
recorte
// Nascimento
```
### 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 nomesobrenome (string nome, string sobrenome)
{
	string nmc = nome + sobrenome;
	string novo = nmc.Substring(0, 7);
	return novo;		
}

string recorte = nomesobrenome ("Rafaela", "Nascimento");
recorte
// Rafaela
```

### Exercício 3
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, int qtd)
{
	bool verificar = cep.Contains("-") && qtd == 9;
	return verificar;
}

bool x = verificarcep ("067990000", 9);
x
// False
```
### Exercício 4
Faça uma função ÚNICA que a partir de um telefone com máscara e DDD
incluído ex. (11) 94343-0808, retorne apenas os números do telefone
ex. 11943430808.
```csharp=
public string substituir (string telefone)
{
	string s = telefone.Replace("(11)", "11");
	return s;
}

string x = substituir ("(11) 94343-0808");
x
//11 94343-0808
```
## 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 ultimodiadomes (DateTime data)
{
	DateTime mes = data.AddMonths(1);
	int d = data.Day;
	DateTime x = mes.AddDays(-d);
	return x;
}

DateTime data1 = new DateTime(2021, 4, 14);
DateTime datafinal = ultimodiadomes (data1);
datafinal
// 4/30/2021
```
### Exercício 2
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 (int ano, int dia, int mes)
{
	DateTime data1 = new DateTime(ano, mes, dia);
    int mes1 = data1.Month;
	bool novo = mes1 >= 1 && mes1 <= 3;
	return novo;
}
bool r = segundotrimestre (2021, 14, 9);
r
// False
```
### Exercício 3
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 maioridade (int ano, int mes, int dia)
{
	DateTime data1 = new DateTime(ano, mes, dia);
	int anoo= data1.Year;
	bool novo = anoo >= 18;
	return novo;
}

bool r = maioridade (2000, 6, 29);
r
// True
```
### Exercício 4
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 primeiraquinzenames (int ano, int mes, int dia)
{
	DateTime data1 = new DateTime(ano, mes, dia);
	int mes1 = data1.Month;
	bool novo = mes1 <= 15;
	return novo;
}

bool r = primeiraquinzenames (2021, 4, 14);
r
// True
```
## 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 int equacaosegundograu (int a, int b, int c)
{
	int resolução = a * a;
	int r = calcularbc (b, c);
	return r;
}

int calcularbc (int b, int c)
{
	int total = b - c;
	return total;
}

double x = equacaosegundograu (2, 24, 8);
x
// 16
```

### 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 double progessãoaritmetica (double primeirotermo, double razao, double posiçao)
{
	double a = primeirotermo + (calcularrp (razao, posiçao));
	return a;
}

public double calcularrp (double razao, double posiçao)
{
	double x = (posiçao - 1) * razao;
	return x;
}

double termo = progessãoaritmetica (2, 2, 5);
termo
// 10
```
### 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 progressãogeometrica (double primeirotermo, double razao, double posiçao)
{
	double a = primeirotermo * Math.Pow(razao, calcularrp (posiçao));
	return a;
}

public double calcularrp (double posiçao)
{
	double x = posiçao - 1;
	return x;
}

double termo = progressãogeometrica (2, 2, 5);
termo
// 32
```
### 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 sobrenomesiguais (string sobrenomepessoa1, string sobrenomepessoa2)
{
	string compararnome1 = ultimonome (sobrenomepessoa1);
	string compararnome2 = ultimonome (sobrenomepessoa2);
	bool compararnomes = sobrenomepessoa1 == sobrenomepessoa2;
	return compararnomes;
}

public string ultimonome (string sobrenomepessoa1)
{
	int a = sobrenomepessoa1.LastIndexOf(" ");
    int b = sobrenomepessoa1.Length;
    string c = sobrenomepessoa1.Trim();
    return c;	
}

bool sobrenome = sobrenomesiguais ("Rafaela Nascimento", "Elisangela Ferreira");
sobrenome
// False
```
