---
# System prepended metadata

title: 'Final session | Fundamentos da Lógica:'

---

# Final session | Fundamentos da Lógica:
>Autor: Guilherme Silva dos Santos
>Número: 12
>Turma: Info D

## Nível I


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

```csharp=
public int AreaTriangulo (int Base, int altura) 
{ 
int area = (Base * altura); 
return area; 
} 
 int x = AreaTriangulo(6,5); 
 x
// 30
```

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

```csharp=
int lado = 8;

int PerimetroOctgono = lado * 8;
PerimetroOctgono
//64
```

### 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 calculo = (basemaior + basEmenor) * altura /2;
return calculo;
}

int x = AreaTrapezio (5,10,14);
x
//105
```

### 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  AreaParalelogramo (int Base, int altura) 
{ 
int area = (Base * altura); 
return area; 
} 
 int x = AreaParalelogramo(5, 6); 
 x
//30
```

## Nível II


### 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=
int catetoOposto = 10;
int catetoAdjascente = 20;

int multiplicacaoHipotenusa = (catetoOposto * catetoOposto) + (catetoAdjascente * catetoAdjascente);
double hipotenusa = Math.Sqrt(multiplicacaoHipotenusa);
double arredondamento = Math.Round(hipotenusa, 0);
arredondamento
//22
```

### 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=
double peso = 42.70;
double altura = 1.66;

double potenciaaltura = Math.Pow(altura, 2);
double imc = peso / potenciaaltura;
double arredondar = Math.Round(imc,0);
arredondar
//15
```

### 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=
double capital = 1200;
double taxaJuros = 0.05;

double soma = (1 + taxaJuros);
double parcelas = Math.Pow(soma, 12);
double montante = capital * parcelas;
double jurosCompostos = montante - capital;
double arredondar = Math.Round (jurosCompostos, 1);
arredondar
//955
```

### 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=
int massa = 10;
int velocidade = 50;

double velocidadePotencia = Math.Pow (velocidade, 2);
double energiaCinética = (massa * velocidadePotencia) / 2;
energiaCinética
//12500
```

### 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=
int raio = 10;
int altura = 20;

double raioPotencia = Math.Pow (raio, 2);
double volumeCilindro = 3.14 * raioPotencia * altura;
volumeCilindro
//6280
```

## Nível III


### Exercício 1
Faça uma função ÚNICA que a partir de um nome completo de uma pessoa, extraia o primeiro nome.
```csharp=
string nomeCompleto = "Guilherme silva dos Santos";
string primeiro = nomeCompleto.Substring(0, 9);
primeiro
//Guilherme   
```

### 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 nome1, string nome2, string nome3, string nome4) { 
string NomeCompleto = nome1 + nome2 + nome3 + nome4; 
string a = NomeCompleto.Substring(17); 
return a; 
}
string X = UltimoNome ("Guilherme", "Silva", "dos", "Santos"); X
//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=
string email = "guilhermebr317@gmail.com";
string dominio = email.Substring(14);
dominio
//@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 ValidarCep (string cep)
{
bool validar = cep.Contains("-");
return validar;
}

bool r = ValidarCep("1548578-5");
r
//True
```

## Nível IV


### 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=
DateTime data = DateTime.Today;
DateTime ultimoDiaDoMes = new DateTime(data.Year, data.Month, DateTime.DaysInMonth(data.Year, data.Month));
ultimoDiaDoMes
//4/30/2021 12:00:00 AM
```

### Exercício 2
Faça uma função ÚNICA que a partir de uma data, descubra o primeiro dia do próximo mês a partir dessa data.
```csharp=
DateTime data = DateTime.Today;
DateTime primeiroDiaDoMes = new DateTime(data.Year, data.Month, 1);
primeiroDiaDoMes
//4/1/2021 12:00:00 AM
```

### 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=
int DataAtual = 13/04/2021;
int DataNascimento = 02/04/2005;
int idade = (DataAtual -  DataNascimento)/ 365;
bool maior = idade >= 18;
return maior;
//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 DateTime Ultimodia (DateTime data)
{
DateTime x = data.AddMonths(1).AddDays(-data.Day + 1);
return x;
}
DateTime X = new DateTime(2012, 05, 16);
X
// 5/16/2012 12:00:00 AM
```

## Nível V


### 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 EquaçaoDoPrimeiroGrau (double a1 , double b1 , double c1 ) { 
 double A = a1;  
 double B = b1;  
 double C = c1; 
 double x = A+B+C; 
 return x ; 
} 
public double valorfinal (double a2 ,double b2 , double c2 ) { 
 double X = EquaçaoDoPrimeiroGrau (a2,b2,c2); 
 double calc = a2+(b2+c2)/X; 
 return calc; 
} 
double e5 = valorfinal (20,15,10); 
Console.WriteLine("5)" + e5);
```

### 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 Conta2 (double posicao, double razao) {
    return (posicao - 1) * razao;
}

double x = TermoGeralPA(2, 2, 102);
x
```

### 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 TermoGeralPG (double PrimeiroTermo, double razao, double posicaoDoTermo){
    double calculoRazao = Math.Pow(razao, CalculoPosicao(posicaoDoTermo));
    double calculoTotal = PrimeiroTermo * calculoRazao;
    return calculoTotal;

}
- [ ] ```[[[](https://)](https://)](https://)

---


### 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 SobrenomeIgual (string a, string b)
{
    string sobrenome1 = UltimoNome(a);
    string sobrenome2 = UltimoNome(b);
    bool s = sobrenome1 == sobrenome2;
    return s;
}

public string UltimoNome (string a)
{
    int espaco1 = a.LastIndexOf(" ");
    int todas1 = a.Length;
    string sobrenome1 = a.Substring(espaco1,todas1-espaco1);
    string f = sobrenome1.Trim();
    return f;

}

string a1= "Guilherme Silva dos Santos";
string b1 = "Silva dos Santos";

bool nome = SobrenomeIgual(a1,b1);
nome
//True
```