---
# System prepended metadata

title: Final Session | Fund. Lógica

---

# Final Session | Fund. Lógica

autor: João Pedro Silva dos Santos 
Turma: INFOA 
Número: 23
 [toc]
## Nivel 1
### Exercicio 1
Faça uma função ÚNICA que a partir da base e altura, calcule a área do triângulo.

```csharp=
public double calcularAreaTriangulo(int basse, int altura)
{
double cal = (basse * altura) / 2;
return cal;
}

double area = calcularAreaTriangulo(25,30);
area
375
````

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

```csharp=
public int CalcularPerimetroOctto (int lado)
{
    int x = 8 * lado;
    return x;
    
}

 int x = CalcularPerimetroOctto (12);

x

96

```

### 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 double calcularTrapézio(double BaseMaior, double BaseMenor, double altura)
{
	double area = (BaseMaior + BaseMenor) * altura;
	return area / 2;
}

double x = calcularTrapézio(10,4,5);
x
 35
```

### 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 CalcularAreaLosango (int D, int d)
{
 int x = D * d;
    int areaLosango = x / 2;
    return x;
    
}
    
 int x = CalcularAreaLosango(12,6);

x
72
```
### Exercício 5
```csharp=
public double calcularParalelogramo(double baseB, double altura)
{
double area = (baseB * altura);
return area;
}
double x = calcularParalelogramo (22,13);
x
286 
```
## 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=
using System;
public int Calcularhipotenusa (int oposto, int adjancente)
{
int x = oposto * oposto + adjancente * adjancente;

return x / 100;
}

int x = Calcularhipotenusa (9,12);
x
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 calcularPeso(double altura, double peso)
 {
     double x = (altura * altura);
     double pesototal = peso / x;
 
double novo = Math.Round(pesototal, 2);
    return novo;
 }
 
double x = calcularPeso(1.67, 70);
 x
25,1

```
### 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 calcularJuros(double capital, double taxa, int tempo)
 {
     double Juros = 1 + (taxa / 100);
     double x = Math.Pow(Juros, tempo);
     double total = capital * x;
    return final;
 }
 
 double x = calcularJuros(1000, 5, 5);
 x
1276,3
```
### Exercicio 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 EnergiaCinética(double massa, double velocidade)
 {
     double x = 00.5;
     double veloci = Math.Pow(velocidade, 2);
     double final = x * massa * veloci;
     return final;
 }
 
 double calcular = EnergiaCinética(55, 3.87);
 calcular
 411,86475

```
### 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(int raio, int altura)
{
double pi = 3.14;
double rai = Math.Pow(raio,2);
double final = pi * rai * altura;
return final;
}

double x = volumeCilindro(5, 9);
x
706,5
```
## 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)
{
    int a = nome.IndexOf(" ");
    string b = nome.Substring(0,a);
    return b;

}
string nome = "João pedro Silva dos Santos";
string c = PrimeiroNome (nome);
c
"João"
```
### 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)
{
    int a = nome.IndexOf(" ");
    string b = nome.Substring(20);
    return b;

}

string x = UltimoNome("João pedro 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=
public string EmailCompleto (string email)
{
    int a = email.IndexOf("@");
    string b = email.Substring(a);
    return b;

}
string nome = "JoãopedroSilvadoSantos@gmail.com";
string c = EmailCompleto (nome);
c
"@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 validar(string CEP)
{
	bool tamanho = CEP.Length == 9;
	bool hifen = CEP.Contains("-");
	
	 bool validado = tamanho == true && hifen == true;
return validado;
}

bool x = validar("04018-002");
x
True
```
## Nível 5
### 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 Ultimodia(DateTime dia)
{
	int d = dia.Day;
	DateTime Mes = dia.AddMonths(1);
	DateTime Dia = a.AddDays(-d);
	DateTime final = dia.AddMonths(1).AddDays(-dia.Day);
	return final;
}

DateTime dia = new DateTime(2021, 4, 16);

DateTime x = Ultimodia(dia);
x

True
```

### 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)
{
	bool a = data.Month >= 4;
	bool b = data.Month <= 6;
	bool final = a == true && b == true;
	return final;
}
DateTime data = new DateTime(2021, 7,14);

bool x = SegundoTrimestre(data);
x
false
```
### 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 Maiorde18(DateTime nascimento)
 {
     DateTime Atual = DateTime.Now;
    bool final = nascimento <= Atual.AddYears(-18);
     return final;
 }
 
 DateTime z = new DateTime(2003, 04, 02);
 
 bool x = Maiorde18(z);
 x
true
```
### 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 quinzena(DateTime dt)
{
	bool a = dt.Day >= 1;
	bool b = dt.Day <= 15;
	bool final = a == true && b == true;
	return final;
}

DateTime dt = new DateTime(2021, 4,14);

bool x = quinzena(dt);
x
true
```
## Nivel 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 valordeA(int a)
 {
     int af = a;
     return af;
 }
 
 public int valordeB(int b)
{
     int bf = b;
     return bf;
 }
 
 public int valordeC(int c)
 {
     int cf = c;
     return cf;
 }
 
 public int calcular(int a, int b, int c)
 {
     int total = valordeA(a) / (valordeB(b) + valordeC(c));
     return total;
 }
 
int x = calcular(8, 5, 3);
 x
1
```
### 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 termos(int Termo1)
 {
     return Termo1;
 }
 
 public int Nprocurar(int Nprocurado)
 {
     int x = Nprocurado - 1;
     return x;
 }

 public int progressão(int razao, int Nprocurado)
 {
     int x = Nprocurar(Nprocurado) * razao;
     return x;
 }
 
 public int PosiçãodoTermo(int razão, int Nprocurado, int Termo1)
 {
     int final = progressão(razão, Nprocurado) + termos(Termo1);
     return final;
 }
 
 int x = PosiçãodoTermo(2, 100, 2);
 200
```
### 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 int Pritermo(int termo)
 {
     return termo;
 }
 
 public int NuProcurado(int Nprocurado)
 {
 
     int x = Nprocurado - 1;
     return x;
 }
 
 public int progressao(int termo, int razao)
 {
     return Pritermo(termo) * razao;
 }

 public double PosicaodoTermo(int termo, int razao, int Nprocurado)
 {
     int c = Pritermo(termo);
     double y = Math.Pow(progressao(termo, razao), NuProcurado(Nprocurado));
     return y;
 }
 
 double x = PosicaodoTermo(1, 3, 15);
 x
 4782969
```
### 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 string UltimoNome (string a)
{
    int espaco1 = a.LastIndexOf(" ");
    int todas1 = a.Length;
    string sobrenome1 = a.Substring(espaco1,todas1-espaco1);
    string k = sobrenome1.Trim();
    return k;
    
}
        

public bool SobrenomeIgual (string a, string b)
{
    string sobrenome1 = UltimoNome(a);
    string sobrenome2 = UltimoNome(b);
    bool x = sobrenome1 == sobrenome2;
    return x;
}    


string a1= "João Pedro Silva";
string b1 = "Luiz Fernando Silva";

bool nome = SobrenomeIgual(a1,b1);
nome

True
```
### Exercício 5
Faça uma função COMPOSTA que a partir de duas datas de nascimento,
retorne verdadeiro/false se as duas pessoas forem do signo de libra.

```csharp=
public bool Libra(DateTime nascimento)
{
bool alt1 = nascimento.Month == 9 && nascimento.Day > 22;
bool alt2 = nascimento.Month == 10 && nascimento.Day > 23;

bool x = alt1 == true || alt2 == true;
return x;
}
DateTime z = new DateTime(2003, 04, 02);
 
 bool x = Libra(z);
x
false

```