---
# System prepended metadata

title: Fund.Logica| final session

---

# 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
```