# Fund.Logica| final session
**Nome** Kevin Ribeiro de Andrade
**Número** 27
**Turma** INFO A
## Nível 1
# Exercício 1
Faça uma função ÚNICA que a partir do lado, calcule o perímetro do
octógono.
```csharp=
public int PerimetroOctogono (int L)
{
int Perimetro = L * 8;
return Perimetro;
}
int x = PerimetroOctogono (10);
x = 8
```
## Exercício 2
Faça uma função ÚNICA que a partir da base e altura, calcule a área do
triângulo.
```csharp=
public double area_triang (double baset, double altura)
{
return (baset * altura) / 2;
}
double x = area_triang(27, 5.5);
//x = 74.25
```
## Exercício 3
Faça uma função ÚNICA que a partir da diagonal maior e menor, calcule a
área do losango.
```csharp=
public double area_losang (double diagonal_maior, double diagonal_menor)
{
return (diagonal_maior * diagonal_menor) / 2;
}
double y = area_losang(4, 2.2);
//y = 4.4
```
## Exercício 4
Faça uma função ÚNICA que a partir da base e altura, calcule a área do
paralelogramo.
```csharp=
public double area_paraleleogramo ( double basek, double altura)
{
return basek * altura;
}
double f = area_paraleleogramo(16, 4.98);
//f = 79.68
```
# NIVEL 2
## Exercício 1
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 energia_cinetica (double velocidade, double massa)
{
double calc = massa * (math.pow(velocidade, 2 ));
return calc / 2;
}
double resul = energia_cinetica (3, 47)
resul
```
## Exercício 2
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 volume_cilindro (double raio_base, double altura)
{
return (Math.Pow(raio_base, 2)) * altura;
}
double r = volume_cilindro(35, 3.7);
r
```
## Exercício 3
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 IMC (double peso, double altura)
{
double calc = peso / Math.Pow(altura, 2);
return Math.Round(calc,2);
}
double l = IMC (35, 1.79);
l = 10.92
```
## Exercício 4
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 JurosCompostos (double capital, int parcelas, double taxa_juros)
{
double calc = capital * Math.Pow(1 + taxa_juros / 100, parcelas);
double adicionando_juros = capital + calc;
return Math.Round(adicionando_juros, 2);
}
double x = JurosCompostos (10000, 5, 7);
x = 24025.52
```
# NIVEL 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 nome(string nome)
{
string corte = nome.Substring(0,5);
return corte;
}
string n = nome("pedro da silva Gomes");
//n = pedro
```
## 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 nome(string nome)
{
string corte = nome.Substring(15,5);
return corte;
}
string n = nome("pedro da silva Gomes");
//n = gomes
```
## 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 email(string nome_email)
{
string recorte = nome_email.Substring(14,10);
return recorte;
}
string s = email("pedrodasilva65@gmail.com");
//s = @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 verificando_CEP (string CEP)
{
long x = CEP.Length;
bool verific = x == 9;
bool verific2 = CEP.Contains("-");
return verific == true && verific2 == true;
}
bool y = verificando_CEP("06198-145");
//y = true
```
# NIVEL 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 TimeSpan ultimo_dia_mes (DateTime mes)
{
DateTime agora = DateTime.Now;
TimeSpan dif = agora - mes;
//DateTime convertendo = Convert.ToDateTime(dif);
return dif;
}
TimeSpan x = ultimo_dia_mes( new DateTime(2021, 03, 30));
//x = 20.22:48:15.2970320
```
## 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 segundo_trimestre ( DateTime agora)
{
DateTime comeco = new DateTime(2021,05,01);
DateTime final = new DateTime(2021,08,30);
long calc = comeco.Month;
long calc2 = final.Month;
long calc3 = agora.Month;
return calc3 <= calc || calc3 >= calc2;
}
bool x = segundo_trimestre(DateTime.Now);
//x = false
```
## Exercício 3
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 primeira_quinzena_mes( DateTime agora)
{
DateTime comeco = new DateTime(2021,05,01);
DateTime final = new DateTime(2021,05,15);
long calc = comeco.Day;
long calc2 = final.Day;
long calc3 = agora.Day;
return calc3 <= calc2;
}
bool y = primeira_quinzena_mes(DateTime.Now);
//y = 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 maior18 ( DateTime nasc)
{
DateTime agora = DateTime.Now;
TimeSpan comp = agora - nasc;
double calc = comp.TotalDays / 365;
return calc >= 18;
}
DateTime v = new DateTime(23,09,20);
bool x = maior18(v);
x = true
```
# Nível 5
## Exercício 1
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 calc_PG (string PG, long termo, double razao)
{
double y = calc1(termo, razao);
return y;
}
public double calc1 (long termo, double razao)
{
double x = termo * (Math.Pow(razao, termo - 1));
return x;
}
double final = calc_PG("3, 6, 12, 24, 48, 96, 192...", 10, 2);
final = 1536
```
## 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 long calc_PA (string PA, long termo_encontrar, long razao)
{
return calc1(PA, termo_encontrar,razao);
}
public long calc1(string PA,long termo, long razao)
{
string convertendo = PA.Substring(0,1);
long termo1 = Convert.ToInt16(convertendo);
return termo1 + ((termo - 1) * razao);
}
long x = calc_PA( "1, 2, 3, 4, 5, 6 , 7, 8...", 10, 1);
x = 10
```
## Exercício 3
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 ultimo_nome (string pessoa1, string pessoa2)
{
return comparando(pessoa1) == comparando2(pessoa2);;
}
public string comparando ( string pessoa1)
{
string corte = pessoa1.Substring(15,5);
return corte;
}
public string comparando2 ( string pessoa2)
{
string cortin = pessoa2.Substring(17,8);
return cortin;
}
bool x = ultimo_nome("alice do satio Souza", "Rodrigo mario dos cavajose");
x = false
```
## Exercício 4
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 de_libra(DateTime nasc, DateTime nasc_2)
{
return nasc1(nasc) == true nasc2(nasc_2) == true;
}
public bool nasc1(DateTime nasc)
{
bool comp = nasc.Month == 9 && nasc.Day > 22;
bool comp2 = nasc.Month == 10 && nasc.Day < 23;
return comp == true comp2 == true;
}
public bool nasc2( DateTime nasc)
{
bool comp = nasc.Month == 9 && nasc.Day > 22;
bool comp2 = nasc.Month == 10 && nasc.Day < 23;
return comp == true || comp2 == true;
}
bool x = de_libra(new DateTime(2021,10, 22), new DateTime (2021,09, 19));
x = false
```
Sign in with Wallet
Connect another wallet