# DevMonk | Trilha de Treinos
[toc]
## TFR<1,1,1>
### Slide 1
#### Exercício 1
Implemente uma função que recebendo um número, calcule a área do quadrado.
```csharp=
public int AreaQuadrado(int lado)
{
int area = lado * lado;
return area;
}
int x = AreaQuadrado(4);
// 16
```
#### Exercício 2
Implemente uma função que recebendo dois números, calcule a área do triângulo.
```csharp=
public double AreaTriangulo(double basee, double altura)
{
return (basee * altura) / 2;
}
double area = AreaTriangulo(2, 2)
// 2
```
#### Exercício 3
Implemente uma função que recebendo dois números, calcule o perímetro do octogono.
```csharp=
public int PerimetroOctogono(int lado)
{
return 8 * lado;
}
int perimetro = PerimetroOctogono(5);
// 40
```
#### Exercício 4
Implemente uma função que recebendo o raio, calcule a área da circunferência.
```csharp=
public double AreaCircunferencia(int raio)
{
double area = Math.PI * Math.Pow(raio, 2);
return area;
}
double area = AreaCircunferencia(4);
//50.2654824574367
```
### Slide 2
#### Exercício 1
Implemente uma função que recebendo um valor em kilos, converta para miligramas.
```csharp=
public double KiloParaMiligramas(double quilo)
{
return quilo * 1000000;
}
double miligramas = KiloParaMiligramas(4);
//4000000
```
#### Exercício 2
Implemente uma função que recebendo três notas, calcule a média simples.
```csharp=
public double MediaSimples(double nota1, double nota2, double nota3)
{
return (nota1 + nota2 + nota3) / 3;
}
double media = MediaSimples(4, 6, 8);
//6
```
#### Exercício 3
Implemente uma função que recebendo a média de um aluno, retorne verd/falso caso a média seja maior ou igual a cinco.
```csharp=
public bool Passou(double nota)
{
bool passou = nota >= 5;
return passou;
}
bool media = Passou(8);
//True
```
#### Exercício 4
Implemente uma função que recebendo três notas, retorne verd/falso caso a média seja menor que cinco.
```csharp=
public bool Reprovou(double nota1, double nota2, double nota3)
{
double media = (nota1 + nota2 + nota3) / 3;
return media < 5;
}
bool media = Reprovou(6, 5, 5);
//False
```
### Slide 3
#### Exercício 1
Implemente uma função que recebendo dois lados de uma forma geométrica, retorne verd/false se a forma for um retângulo.
```csharp=
public bool IsFormaRetangulo(int largura, int comprimento)
{
return largura != comprimento;
}
bool medidas = IsFormaRetangulo(10, 7);
//True
```
#### Exercício 2
Implemente uma função que recebendo a base e altura de dois retângulos, retorne verd/false se as áreas forem iguais.
```csharp=
public bool AreaIguais(double base1, double altura1, double base2, double altura2)
{
return base1 * altura1 == base2 * altura2;
}
bool area = AreaIguais(2, 4, 8, 10);
//False
```
#### Exercício 3
Implemente uma função que recebendo o raio e altura de dois cilindros, retorne verd/false se o volume do primeiro cilindro cabe no segundo.
```csharp=
public bool CabeNoRecipiente(double raio1, double altura1, double raio2, double altura2)
{
double cilindro1 = Math.PI * Math.Pow(raio1, 2) * altura1;
double cilindro2 = Math.PI * Math.Pow(raio2, 2) * altura2;
bool cabe = cilindro1 <= cilindro2;
}
bool volume = CabeNoRecipiente(2, 4, 10, 8);
//True
```
### Slide 4
#### Exercício 1
Implemente uma função que recebendo um valor textual que representa um mês, retorne verd/false se o mês pertence ao terceiro trimestre.
```csharp=
public bool IsTerceiroTrimestre(string mes)
{
return mes == "Julho" || mes == "Agosto" || mes == "Setembro";
}
bool trim3 = IsTerceiroTrimestre("Maio");
//False
```
#### Exercício 2
Implemente uma função que recebendo a temperatura atual do dia e um valor numérico com a hora atual, retorne se a pessoa deve sair para passear no parque, caso a temperatura esteja entre 20 e 30 e o horário entre 08 e 15.
```csharp=
public bool VamosAoParque(int hora, double temperatura)
{
bool horaOk = hora >= 08 && hora <= 15;
bool tempOk = temperatura >= 20 && temperatura <= 30;
return horaOk && tempOk;
}
bool parque = VamosAoParque(20, 25);
//False
```
#### Exercício 3
Implemente uma função que recebendo o ano de nascimento e o nome de uma pessoa, retorne o texto: XXX sua idade no ano atual será XXX anos"
```csharp=
public string MinhaIdadeEsseAno(int ano, string nome)
{
DateTime anoatual = DateTime.Now;
int diferenca = anoatual.Year - ano;
string frase = nome + " sua idade no ano atual será " + diferenca + " anos.";
return frase;
}
string idade = MinhaIdadeEsseAno(2003, "Gabriel");
//Gabriel sua idade no ano atual será 18 anos.
```
### Slide 5
#### Exercício 1
Implemente uma função que recebendo o valor total de uma compra, a quantidade de parcelas e a taxa de juros por mês, calcule o valor final da compra considerando juros simples.
```csharp=
public double JurosSimples(double totalcompra, int parcelas, double juros)
{
double porcentagem = juros / 100;
double jurosimples = totalcompra * porcentagem * parcelas;
double total = totalcompra + jurosimples;
return total;
}
double subtotal = JurosSimples(200, 2, 5);
//220
```
#### Exercício 2
Implente uma função que recebendo o primiero termo de uma PA (progressão aritmética), a razão e a posição do termo que deseja encontrar, retorne o valor encontrado desse termo.
```csharp=
public int BuscarTermoPA(int termo1, int razao, int posicao)
{
return termo1 + (posicao - 1) * razao;
}
int termo = BuscarTermoPA(5, 3, 5);
//17
```
### Slide 6
#### Exercício 1
Em uma venda de Açaí, onde são informadas as quantidades de açaí pequenos, médios e grandes, calcule o total a pagar sabendo que os preços do açaí são R$10,00, R$12,00, R$14,00 respectivamente e não sofrerão alteração de preço.
```csharp=
public int PrecoAcai(int pequeno, int medio, int grande)
{
int acaipequeno = pequeno * 10;
int acaimedio = medio * 12;
int acaigrande = grande * 14;
int total = acaipequeno + acaimedio + acaigrande;
return total;
}
int preco = PrecoAcai(2, 4, 3);
//110
```
#### Exercício 2
Em uma competição de arco e flecha as possibilidades de pontos são 10, 25 e 50 dependendo de onde a flecha acertar no alvo. Cada arqueiro possui 5 flechas. A partir da quantidade de flechas acertadas em 10, 25 e 50, calcule a quantidade de pontos do arqueiro.
```csharp=
public int PontucaoArqueiro(int alvo1, int alvo2, int alvo3)
{
return (alvo1 * 10) + (alvo2 * 25) + (alvo3 * 50);
}
int total = PontucaoArqueiro(1, 1, 3);
//185
```
### Slide 7
#### Exercício 1
Em uma estrada com limnite de velocidade de 110 km/hora, os carros viajam de uma cidade a outra e ocasionalmente param de funcionar. A partir do quilômetro da estrada em que o carro parou e o quilômetro de onde se encotra o posto policial, calule quantos minutos levará para o carro receber atendimento do posto policial.
```csharp
public double AtendimentoPolicial(double quilometragem)
{
return quilometragem / 110;
}
double tempo = AtendimentoPolicial(120);
//1.090
```
#### Exercício 2
Uma pessoa monta seu lanche da manhã pela quantidade de fatias de pão de forma, fatias de mussarela e presunto. Sua nutricionista lhe informou o total de calorias que podem ser gastas no lanche da manhã. Retorne verdadeiro/falso se o lanche montado pela pessoa está saudável conforme o limite estipulado por sua nutricionista. (Pesquise as calorias das fatias de pão, mussarela e presunto na internet)
```csharp
public bool CaloriasPermitidas(int pao, int mussarela, int presunto, double nutricionistacal)
{
int calorias = (pao * 120) + (mussarela * 65) + (presunto * 14);
return calorias <= nutricionistacal;
}
bool calorias = CaloriasPermitidas(5, 10, 9, 540);
//False
```
### Slide 8
#### Exercício 1
Uma equipe de voluntários prepara marmitas para desabrigados, no fim de cada semana as marmitas são preparadas utilizando os ingredientes recebidos através de doação. Cada marmita pesa em média 800 gramas. Os voluntários possuem um cadastro das pessoas que irão receber a família. A partir do número de pessoas cadastradas, crie uma função que informe quantos quilos de arrecadação são necessários para atender a todos.
```csharp
public double QuilosNecessarios(int pessoas)
{
return pessoas * 800.00 / 1000;
}
double quilos = QuilosNecessarios(4);
//3.2
```
#### Exercício 2
A partir do total de uma compra realizada online, você deve calcular o valor total considerando o total de parcelas, sabendo que há juros de 2% por mês. Considere também o valor do frente e da garantia estendida em anos. Cada ano da garantia estendida, aumenta 5% no valor da compra.
```csharp=
public double ValorCompra (double valorParcelas, int parcelas, double frete, double valorGarantia, int anosGarantia)
{
double valortotal = valorParcelas * parcelas;
double jurosMes = valorParcelas * 0.02 * parcelas;
double JurosAno = valorGarantia * 0.05 * anosGarantia;
return valortotal + jurosMes + JurosAno + frete;
}
double total = ValorCompra(50, 4, 15, 50, 2);
//224
```
### Slide 9
#### Exercício 1
Um grupo de amigos querem realizar um churrasco para comemorar uma data especial. Eles precisam descobrir quanto cada um precisa contribuir de dinheiro. No churrasco terá carne, calabresa, queijo coalho e pão de alho. A carne e a calabresa é cobrada a partir dos quilos, o quejo coalho e o pão de algo são cobrados por unidade do pacote. A partir da quantidade de comida informada para cada aliment e do total de pessoas participantes do churrasco, crie uma função que calcule o valor que cada uma precisa contribuir.
```csharp=
public double Contribuicao(int pessoas, double quiloCarne, double quiloCalabresa, int pacotePao, int pacoteQueijo, double valorCarne, double valorCalabresa, double valorPao, double valorQueijo)
{
double carne = quiloCarne * valorCarne;
double calabresa = quiloCalabresa * valorCalabresa;
double pao = pacotePao * valorPao;
double queijo = pacoteQueijo * valorQueijo;
return (carne + calabresa + pao + queijo) / pessoas;
}
double total = Contribuicao(5, 5, 4, 5, 5, 25, 12, 8, 10);
//52.6
```
#### Exercício 2
Uma compra online paga com cartão de crédito permite que o pagamento seja realizado se o total na conta corrente for superior ao valor da compra. Se o valor na conta corrente for menor , o banco ainda considera o valor do cheque especial para permitir a compra, se o valor da conta corretente considerando o cheque especial ainda for menor , a compra não é permitida. A partir do valor da compra do total de parcelas e savendo o que o juros é de 2% ao mês, crie uma função que retorne verdadeiro se a compra for aprovada e falso caso não seja.
```csharp=
public bool PermissaoCartaoCredito(double conta, double valorCompra, int parcelas, double cheque)
{
double valorParcelas = valorCompra / parcelas;
double juros = valorParcelas * 0.02 * parcelas;
double total = valorCompra + juros;
return total <= conta || total <= conta + cheque;
}
bool permissao = PermissaoCartaoCredito(1000, 3000, 6, 3000);
//True
```
### Slide 10
#### Exercício 1
Você decidiu maratonar uma série nova da Netflix e quer descobrir quantas
s irá levar para terminá-la. Em cada dia da semana você tem uma quantidade de horas diferente para poder assistir a série. A partir da quantidade de horas disponíveis em cadsa dia da semana, do total de episódios e da média em minuto dos episódios, crie uma função que calcule quantas semanas levará para zerar a série.
```csharp=
public double SemanasParaMaratonar(int seg, int ter, int qua, int qui, int sex,
int sab, int dom, int qtdEpisodios, double tempoEp)
{
double totalMinutosDisp = (seg + ter + qua + qui + sex + sab + dom) * 60;
double totalMinutosSerie = qtdEpisodios * tempoEp;
double semanas = totalMinutosSerie / totalMinutosDisp;
return semanas;
}
double x = SemanasParaMaratonar(1, 1, 1, 1, 1, 1, 1, 14, 60);
//2
```
#### Exercício 2
para ir e voltar do trabalho uma pessoa abastece o carro semanalmente. A distância percorrida na ida e volta são diferentes, já que ele percorre caminhos diferentes para fugir do trânsito. No dia do rodízio, ele ainda percorre outros caminhos de ida e volta para não levar multa. Sabendo que a pessoa trabalha apeas de segunda a sexta e que o carro será abastecido com gasolina, calcule o total que será gasto no mês considerando que um mês possui 4 semanas. Crie uma função para calcular o total gasto a partir das quilometragens de ida e volta, considerando o dia do rodízio e o consumo por litro do veículo.
```csharp=
public double TotalAbastecimento(double ida, double volta, double idaRodizio, double voltaRodizio,
double consumoPorLitro)
{
double totalKmSemana = (ida + volta) * 4 + idaRodizio + voltaRodizio;
double totalKmMes = totalKmSemana * 4;
double totalLitros = totalKmMes / consumoPorLitro;
double totalPagar = totalLitros * 4.8;
return totalPagar;
}
double total = TotalAbastecimento(5, 5 , 5, 5, 12);
//80
```
# Nível 2
### Slide 1
#### Exercício 1
Implemente uma função que recebendo o cateto oposto e adjacente, calcule a hipotenusa.
```csharp=
public double Hipotenusa(double catetOposto, double adjacente)
{
double hipotenusa = Math.Pow(catetOposto, 2) + Math.Pow(adjacente, 2);
return Math.Sqrt(hipotenusa);
}
double hipotenusa = Hipotenusa(4, 4);
//5,656854249492381
```
#### Exercício 2
Implemente umna função que recebendo um nome completo, retorne o primeiro nome.
```csharp=
public string PrimeiroNome(string nomeCompleto)
{
int nome = nomeCompleto.IndexOf(" ");
return nomeCompleto.Substring(0, nome);
}
string nome = PrimeiroNome("José Paulo de Oliveira");
//José
```
#### Exercício 3
Implemente uma função que recebendo uma data, retorne o último dia do mês referente a essa data.
```csharp=
public DateTime UltimoDia(DateTime data)
{
return data.AddMonths(1).AddDays(-data.Day);
}
DateTime diaMes = UltimoDia(new DateTime (2021, 06, 01));
//30/06/2021 00:00:00
```
### Slide 2
#### Exercício 1
Implemente uma função que recebendo uma altura e peso de uma pessoa, calcule o IMC.
```csharp=
public double Imc(double altura, double peso)
{
return peso / Math.Pow(altura, 2);
}
double imc = Imc(1.50, 48);
// 21,333333333333332
```
#### Exercício 2
Implemente uma função que recebendo um nome completo, retorne o último nome.
```csharp=
public string UltimoNome(string nomeCompleto)
{
int nome = nomeCompleto.LastIndexOf(" ");
return nomeCompleto.Substring(nome);
}
string nome = UltimoNome("Jose Luis Oliveira");
//Oliveira
```
#### Exercício 3
Implemente uma função que recebendo uma data, retorne o primeiro dia do próximo mês referente a essa data.
```csharp=
public DateTime PrimeiroDiaProximoMes(DateTime data)
{
return data.AddMonths(1).AddDays(data.Day - data.Day);
}
DateTime primeiroDia = PrimeiroDiaProximoMes(new DateTime (2021, 06, 01));
//01/07/2021 00:00:00
```
### Slide 3
#### Exercício 1
Implemente uma função que recebendo o valor de um automóvel, a quantidade de parcelas e a taxa, calcule o valor final aplicando os juros compostos com arredondamento de duas casas decimais.
```csharp=
public double CompraAutomovel(double valorAutomovel, int parcelas, double juros)
{
double valorParcela = valorAutomovel / parcelas;
double porcentagem = juros / 100;
double jurosComposto = valorParcela * Math.Pow(( 1 + porcentagem), parcelas) + valorAutomovel;
return Math.Round(jurosComposto, 2);
}
double total = CompraAutomovel(10000, 5, 2);
//12208,16
```
#### Exercício 2
Implemente uma função que recebendo um Tweet, retorne verdadeiro se a quantidade de caracters sem considerar os espaços for menor que 140.
```csharp=
public bool TweetValido(string tweet)
{
int frase = tweet.Trim().Length;
return frase < 140;
}
bool frase = TweetValido("Treino de lógica");
//True
```
#### Exercício 3
Implemente uma função que a partir de uma data, informe se o mês referente termina em 31 dias.
```csharp=
public bool Possui31Dias(DateTime data)
{
DateTime diaMes = data.AddMonths(1).AddDays(-data.Day);
return diaMes.Day == 31;
}
bool mes = Possui31Dias(new DateTime(2021,05,01));
//True
```
### Slide 4
#### Exercício 1
Implemente uma função que recebendo uma número de telefone com DDD, retorne o número aplicando a máscara (##) #####-####.
```csharp=
public string MascaraTelefone(long numero)
{
string conversao = Convert.ToString(numero);
string ddd = conversao.Substring(0,2);
string metade1 = conversao.Substring(2, 5);
string metade2 = conversao.Substring(7);
string formatacao = string.Format($"({ddd})" + metade1 + "-" + metade2);
return formatacao;
}
string telefone = MascaraTelefone(11965258749);
//(11)96525-8749
```
#### Exercício 2
Implemente uma função que recebendo um Tweet, retorne as Hashtags informadas ao final da mensagem.
Ex: "Bora codar aí dev!! #Devmonk#SangueNosOio"
Resp.: "#Devmonk#SangueNosOio"
```csharp=
public string TweetHashtags(string frase)
{
int posicao = frase.IndexOf("#");
return frase.Substring(posicao);
}
string tweet = TweetHashtags("Bora codar aí dev!! #Devmonk#SangueNosOio");
//#Devmonk#SangueNosOio
```
#### Exercício 3
Implemente uma função que a partir de uma data, informe se a mesma cai em uma sexta-feira 13.
```csharp=
public bool SextaFeira13(DateTime data)
{
return data.Day == 13 && data.DayOfWeek == DayOfWeek.Friday;
}
bool dia = SextaFeira13(new DateTime(2021,05,13));
//False
```
### Slide 5
#### Exercício 1
Implemente uma função que recebendo uma mensagem, retorne verd/ falso caso a frase possua todas as vogais do alfabeto.
```csharp=
public bool PossuiTodasVogais(string frase)
{
return frase.Contains("a") && frase.Contains("e") && frase.Contains("i") &&
frase.Contains("o") && frase.Contains("u");
}
bool frase = PossuiTodasVogais("a");
//False
```
#### Exercício 2
Implemente uma função que recebendo uma palavra composta, retorne a palavra composta invertida. Ex.: Guarda-Chuva >> Chuva-Guarda.
```csharp=
public string InverterPalavrasComposta(string palavra)
{
int corte1 = palavra.IndexOf("-");
string posicao1 = palavra.Substring(0, corte1);
int corte2 = palavra.IndexOf("-");
string removeHifen = palavra.Substring(corte2);
string posicao2 = removeHifen.Substring(1);
return $"{posicao2}-{posicao1}";
}
string palavra = InverterPalavrasComposta("Guarda-Chuva");
//Chuva-Guarda
```
#### Exercício 3
Implemente uma função que a partir de uma senha informada pelo usuário, retorne verd/falso caso a senha seja uma senha forte. Uma senha forte possui no mínimo 8 caracteres, pelo menos 1 caractere especial e 1 número.
```csharp=
public bool SenhaForte(string senha)
{
bool caracteresEspeciais = Regex.Match(senha, "^.*([0-9]+.*[!@#$%&]+|[!@#$%&]+.*[0-9]+).*$").Length >= 8;
return caracteresEspeciais;
}
bool senhaForte = SenhaForte("senhaforte42@");
Console.WriteLine(senhaForte);
//True
```
### Slide 6
#### Exercício 1
Implemente uma função que recebendo uma data de aniversário, retorne quantos dias a pessoa possui de vida
```csharp=
public double DiasDeVida(DateTime data)
{
TimeSpan da = DateTime.Today - data;
return da.TotalDays;
}
double data = DiasDeVida(new DateTime(2005,09,27));
//5700
```
#### Exercício 2
Implemente uma função que recebendo uma data de nascimento com hora, minuto e segundo, retorne verd/falso caso a pessoa tenha nascido à noite.
```csharp=
public bool NascimentoANoite(DateTime data)
{
return data.Hour >= 18 && data.Hour <= 24;
}
bool noite = NascimentoANoite(new DateTime(2021,02,14,23,05,45));
//True
```
#### Exercício 3
Implemente uma função que descubra se duas pessoas nasceram no mesmo dia e mês independente do ano.
```csharp=
public bool NasceuNoMesmoDia(DateTime dataPessoa1, DateTime dataPessoa2)
{
return dataPessoa1.DayOfWeek == dataPessoa2.DayOfWeek;
}
bool data = NasceuNoMesmoDia(new DateTime (2003,06,20), (new DateTime(2003,05,20)));
//False
```
### Slide 7
#### Exercício 1
Implemente uma função que implemente a lógica para descobrir se duas datas pertencem ao mesmo trimestre.
```csharp=
public bool MesmoTrimestre(DateTime data1, DateTime data2)
{
bool trimestre1 = (data1.Month >= 01 && data2.Month >= 01) && (data1.Month <= 03 && data2.Month <= 03);
bool trimestre2 = (data1.Month >= 04 && data2.Month >= 04) && (data1.Month <= 06 && data2.Month <= 06);
bool trimestre3 = (data1.Month >= 07 && data2.Month >= 07) && (data1.Month <= 09 && data2.Month <= 09);
bool trimestre4 = (data1.Month >= 10 && data2.Month >= 10) && (data1.Month <= 12 && data2.Month <= 12);
return (trimestre1) || (trimestre2) || (trimestre3) || (trimestre4);
}
bool data = MesmoTrimestre(new DateTime (2003,03,20), (new DateTime(2003,09,20)));
//False
```
#### Exercício 2
Implemente uma função que implemente a lógica para descobrir se uma pessoa possui mais de 18 anos.
```csharp=
public bool PessoaDeMaior(DateTime data)
{
DateTime atual = DateTime.Now;
DateTime anos = atual.AddYears(-18);
return data <= anos;
}
bool data = PessoaDeMaior(new DateTime(2003,05,13));
//True
```
#### Exercício 3
Implemente uma função que aplique a máscara de um CPF em um texto recebido. O texto pode vir formatado de forma correta ou incorreta, ou ainda, vir apenas os números, por isso remova qualquer caracter especial antes de aplicar a formatação.
```csharp=
public string MascaraCpf(string cpf)
{
string formatacao = cpf.Trim();
string remocaoCaracters = formatacao.Replace(".", "").Replace("-", "");
string parte1 = remocaoCaracters.Substring(0,3);
string parte2 = remocaoCaracters.Substring(3,3);
string parte3 = remocaoCaracters.Substring(6,3);
string parte4 = remocaoCaracters.Substring(9,2);
string juncao = $"{parte1}.{parte2}.{parte3}-{parte4}";
return juncao;
}
string cpf = MascaraCpf("12345678909");
//123.456.789-09
```
#### Exercício 4
Implemente uma função que valide se um CEP é válido, ou seja, se ele possui 9 caracteres e possui um hífen no sexto caractere.
```csharp=
public bool ValidaCep(string cep)
{
//80449-030
int qtdCep = cep.Length;
bool tamanho = qtdCep == 9;
bool hifen = cep[5] == '-';
return (tamanho) && (hifen);
}
bool cep = ValidaCep("04944-694");
//True
```
#### Exercício 5
Implemente uma função que calcule o volume de dois cilindros e informe se seria possível colocar o conteúdo do primeiro cilindro no conteúdo do segundo.
```csharp=
public bool CabeNoRecipiente(double raio1, double altura1, double raio2, double altura2)
{
double cilindro1 = Math.PI * Math.Pow(raio1, 2) * altura1;
double cilindro2 = Math.PI * Math.Pow(raio2, 2) * altura2;
bool cabe = cilindro1 <= cilindro2;
}
bool volume = CabeNoRecipiente(2, 4, 10, 8);
//True
```
### Slide 8
#### Exercício 1
Implemente uma função que implemente a lógica para calcular uma equação de segundo grau. A função irá receber os termos 'a', 'b' e 'c' e retornar os valores de x¹ w x² concatenados.
```csharp=
public string EquacaoSegundoGrau(double a, double b, double c)
{
double delta = Math.Pow(b,2) - 4 * a * c;
double x1 = (-(b) + Math.Sqrt(delta)) / 2*(a);
double x2 = (-(b) - Math.Sqrt(delta)) / 2*(a);
return $"S=({x2},{x1})";
}
string solucao = EquacaoSegundoGrau(1, 1, -12);
// S=(-4,3)
```
#### Exercício 2
Implemente uma função que implemente a lógica para encontrar um termo de uma PG (Progressão Geométrica). A função deverá receber o primeiro termo, junto a razaão e a posição do termo que deseja encontrar.
```csharp=
public double ProgressaoGeometrica(double termo1, double razao, double termoDesejado)
{
double termo = termo1 * Math.Pow(razao, termoDesejado - 1);
return termo;
}
double termo = ProgressaoGeometrica(1, 2, 6);
// 32
```
#### Exercício 3
```csharp=
public bool MesmaFamilia(string pessoa1, string pessoa2, string pessoa3)
{
int posicaoSobrenome1 = pessoa1.LastIndexOf(" ");
string sobrenomePessoa1 = pessoa1.Substring(posicaoSobrenome1);
int posicaoSobrenome2 = pessoa2.LastIndexOf(" ");
string sobrenomePessoa2 = pessoa2.Substring(posicaoSobrenome2);
int posicaoSobrenome3 = pessoa3.LastIndexOf(" ");
string sobrenomePessoa3 = pessoa3.Substring(posicaoSobrenome3);
return sobrenomePessoa1 == sobrenomePessoa2 && sobrenomePessoa1 == sobrenomePessoa3;
}
bool familia = MesmaFamilia("José Silva Santos", "Julia Silva Santos", "Beatriz Pereira da Silva");
//False
```
Google Drive
Gist
Clipboard
Sign in with Wallet
