---
# System prepended metadata

title: Session seven | Fund.Logica | 2°bimestre

---

# Session seven | Fund.Logica | 2°bimestre

**Nome** Kevin Ribeiro de Andrade
**Número** 27
**Turma** INFO A


## Exercício 1

Crie a(s) classe(s) representando a abstração de função e/ou dados ao lado. Abaixo a 
especificação das situações a serem resolvidas:
▪ Realize a lógica para implementar uma função que recebendo uma lista de números 
inteiros, some apenas os números ímpares. 
Ex. ({2, 3, 4, 5}) => 8
▪ Realize a lógica para implementar uma função que recebendo uma lista de números 
inteiros, calcule a potência ao cubo de cada item. 
Ex. ({2, 3, 4}) => {8, 27, 64}
▪ Realize a lógica para implementar uma função que recebendo uma lista de números 
decimais, calcule a raiz quadrada de cada item. 
Ex. ({25, 16, 9}) => {5, 4, 3}
▪ Realize a lógica para implementar uma função que recebendo uma lista de números 
inteiros, retorne o maior número. 
Ex. ({25, 16, 39}) => 39
▪ Realize a lógica para implementar uma função que recebendo uma lista de números 
decimais, retorne a média dos números. 
Ex. ({6,7,5,6}) => 6
▪ Realize a lógica para implementar uma função que calcule a média a partir de uma 
lista de notas.
Ex. ({5,5,5}) => 5, ({6,8}) => 7, ({4,6,8, 10}) => 7
▪ Realize a lógica para implementar uma função que recebendo uma lista de 
Retângulos, retorne uma lista com a área de cada Retângulo.
Ex. ({ [2,4], [4,4], [5,4] }) => {8, 16, 20}
```csharp=
using System;
using System.Collections.Generic;

public class Retangulo 
{
	public double Altura {get; set;}
	public double Base {get; set;}
}

public class Notas
{
	public double Nota1 {get; set;}
	public double Nota2 {get; set;}
	public double Nota3 {get; set;}
}

public class TreinoFocadoA
{
	public int SomandoImpares (List<int> valor)
	{
		int Soma = 0;
		
		foreach(int cont in valor)
		{
			//int somando = 0;
			if (cont % 2 != 0)
			{
				Soma = Soma += cont;
			}
		}
		return Soma;
	}
	
	public List<int> CalcularCubo (List<int> Number)
	{
		List<int> Numero = new List<int>();
		
		foreach(int num in Number)
		{
             
			Numero.Add(Convert.ToInt32(Math.Pow(num, 3)));
		}
		return Numero;
	}
	
	public List<double> CalcularRaiz (List<double> Number)
	{
		List<double> Raiz = new List<double>();
		
		foreach (double num in Number)
		{
			Raiz.Add(Math.Round(Math.Sqrt(num), 2));
		}
		return Raiz;
	
	}
	
	public int MaiorNumero (List<int> Number)
	{
		int maior = 0;
		foreach (int num in Number)
		{
			if (num > maior)
				maior = num;
		}
		return maior;
	}
	
	public double Media (List<double> Valor)
	{
		double media = 0;
		foreach (double num in Valor)
		{
			media += num;
		}
       return media / Valor.Count;
	}
	
	public List<double> CalcularMedia (List<Notas> Nota)
	{
		List<double> Media = new List<double>();
		foreach (Notas num in Nota)
		{
			Media.Add((num.Nota1 + num.Nota2 + num.Nota3) / 3);
		}
		return Media;
	}
	
	private double AreaRetangulo (Retangulo ret)
	{
		return ret.Base * ret.Altura;
	}

	public List<double> CalcularRetangulo (List<Retangulo> ret)
	{
		List<double> resul = new List<double>();
		
		foreach (Retangulo retang in ret)
		{
			resul.Add(AreaRetangulo(retang));
		}
		return resul;
	}
}

TreinoFocadoA TFA = new TreinoFocadoA();

List<int> ValorFuncao1 = new List<int>() {3,3, 4};

//List<int> SomarImpar = 
int x = TFA.SomandoImpares(ValorFuncao1);
//Console.WriteLine(string.Join("|", SomarImpar));
Console.WriteLine(x);

List<int> ValoresPraElevarCubo = new List<int>();
ValoresPraElevarCubo.Add(2);
List<int> Cubo = TFA.CalcularCubo(ValoresPraElevarCubo);
Console.WriteLine(string.Join("|", Cubo));

List<double> Valor2 = new List<double>(){6, 25, 7};

List<double> Raiz = TFA.CalcularRaiz(Valor2);

Console.WriteLine(string.Join("|", Raiz));

List<int> Valores2 = new List<int>() {67,89,3};

int MaiorNum = TFA.MaiorNumero(Valores2);

Console.WriteLine(MaiorNum);

List<Notas> Nt = new List<Notas> {
	new Notas {Nota1 = 2, Nota2 = 2, Nota3 = 2},
	new Notas {Nota1 = 3, Nota2 = 3, Nota3 = 3}
};

List<double> Medias = TFA.CalcularMedia(Nt);
Console.WriteLine(string.Join("|", Medias));

List<Retangulo> ret = new List<Retangulo>() {
	new Retangulo {Base = 2, Altura = 2},
	new Retangulo {Base = 3, Altura = 3}
};

List<double> CalculandoRetangulo = TFA.CalcularRetangulo(ret);
Console.WriteLine(string.Join("|", CalculandoRetangulo));
```

## Exercício 2

Crie a(s) classe(s) representando a abstração de função e/ou dados ao lado. Abaixo a 
especificação das situações a serem resolvidas:
▪ Realize a lógica para implementar uma função que recebendo uma lista de datas, gere 
uma lista com o último dia do mês de cada item da lista recebida. 
Ex. ({ [14/04/2021], [15/05/2021] }) => { [30/04/2021], [31/05/2021] }
▪ Realize a lógica para implementar uma função que recebendo uma lista de datas, 
retorne qual é a maior data entre elas. 
Ex. ({ [14/06/2021], [16/06/2021], [10/06/2021] }) => [16/06/2021]
▪ Realize a lógica para implementar uma função que retorne uma lista com as pessoas 
maiores de 18 anos a partir de uma lista de pessoas.
▪ Realize a lógica para implementar uma função que retorne se todos de uma lista de 
pessoas são maiores de 18 anos.
```csharp=
using System;
using System.Collections.Generic;

public class Pessoa
{
	public string Nome {get; set;}
    public DateTime Nasc {get; set;}
	
	public override string ToString()
	{
		return $"{Nome}, {Nasc}";
	}
}

public class TreinoFocadoB
{
	public List<DateTime> LastDayInMonth (List<DateTime> Data)
	{
		List<DateTime> UltimoDia = new List<DateTime>();
		
		foreach (DateTime dt in Data)
		{
			UltimoDia.Add(new DateTime(dt.Year, dt.Month, DateTime.DaysInMonth(dt.Year, dt.Month)));
		}
		return UltimoDia;
	}
	
	public DateTime MaiorData (List<DateTime> data)
	{
		DateTime Dt = DateTime.Today;
		
		foreach (DateTime dt in data)
		{
			if (dt > Dt)
				Dt = dt;
		}
       return Dt;
	}
	
	public List<Pessoa> FiltrarMaiores18 (List<Pessoa> p)
	{
		List<Pessoa> Humano = new List<Pessoa>();
		
		foreach(Pessoa P in p)
		{
			if ((DateTime.Today - P.Nasc).TotalDays / 365 >= 18)
				Humano.Add(P);
		}
		return Humano;
	}
	
	public bool TodosMaiores18 (List<Pessoa> p)
	{
		bool DeMaior = true;
		
		foreach (Pessoa P in p)
		{
			if ((DateTime.Now - P.Nasc).TotalDays / 365 <= 18)
			{
				DeMaior = false;
				break;
			}
		}
		return DeMaior;
	}
}
TreinoFocadoB TFB = new TreinoFocadoB();

List<DateTime> Data = new List<DateTime>() {
	{DateTime.Today},
	{new DateTime(2023, 08, 13)},
	{new DateTime(1989,02, 12)}
										   
										   };
List<DateTime> LastDayMonth = TFB.LastDayInMonth(Data);
Console.WriteLine(string.Join(" | ", LastDayMonth));

DateTime data = TFB.MaiorData(Data);
Console.WriteLine(data);

List<Pessoa> p = new List<Pessoa> () {
	new Pessoa {Nome = "Oi", Nasc = new DateTime(1980, 06, 13)},
	new Pessoa {Nome = "Hi", Nasc = DateTime.Today},
	new Pessoa {Nome = "Hello world", Nasc = new DateTime(1999, 02, 27)}
};

List<Pessoa> FiltrandoMaiores = TFB.FiltrarMaiores18(p);
Console.WriteLine(string.Join(" | ", FiltrandoMaiores));

bool Maiores18 = TFB.TodosMaiores18(p);
Console.WriteLine(Maiores18);
```


## Exercício 3
Crie a(s) classe(s) representando a abstração de função e/ou dados ao lado. Abaixo a 
especificação das situações a serem resolvidas:
▪ Realize a lógica para implementar uma função que separe cada caractere de uma frase 
por um hífen. Ex. ("Olá, tudo bem?") => "O-l-á- t-u-d-o- -b-e-m-?-“
▪ Realize a lógica para implementar uma função que receba uma palavra e retorne uma 
lista contendo o código referente a tabela ASCII de cada caractere.
Ex. (“Bruno”) => {66, 114, 117, 110, 111}
▪ Realize a lógica para implementar uma função que verifica se todos caracteres de uma 
frase são vogais
Ex. ("Olá") => false, ("Eaee") => true
▪ Realize a lógica para implementar uma função que alterne entre maiúsculo e minúsculo 
cada caractere de um nome de pessoa. 
Ex. (["Bruno de Oliveira", [22/10/89], “SP”) => “BrUnO De oLiVeIrA“
▪ Realize a lógica para implementar uma função que inverte os caracteres de uma frase.
Ex. ("Olá, tudo bem?") => "?meb odut ,álO“
▪ Realize a lógica para implementar uma função que recebendo uma palavra, retorne 
true/false, caso essa palavra seja um palíndromo.
Ex. (“osso”) => true

```csharp=
using System;
using System.Collections.Generic;

public class Pessoa
{
	public string Nome {get; set;}
	public DateTime Nasc {get; set;}
	public string Cidade {get; set;}
	
	public override string ToString()
	{
		return $"{Nome}, {Nasc}, {Cidade}";
	}
}

public class TreinoFocadoC 
{
	public string FraseComTracinho (string frase)
	{
		string FraseSeparada = string.Empty;
		
		foreach (char cont in frase)
		{
			FraseSeparada +=  cont + "-";
		}
		return FraseSeparada;
	}
	
	public List<int> CodigoAscii (string frase)
	{
		List<int> Ascii = new List<int>();
		
		foreach (char cont in frase)
		{
			Ascii.Add(Convert.ToInt32(cont));
		}
		return Ascii;
	}
	
	public bool TodasVogais (string frase)
	{
		bool AllVogais = true;
		
		foreach (char cont in frase)
		{
			if (cont != 'A' && cont != 'a' && cont != 'E' && cont != 'e' &&
               cont != 'I' && cont != 'i' && cont != 'O' && cont != 'o' &&
				cont != 'U' && cont != 'u')
			{
                AllVogais = false;
				break;
			}
		}
		
		return AllVogais;
	}
		
		public string Alternar (Pessoa P)
		{
			string FraseAlternada = string.Empty;
			//char anterior = ' ';
			int num = 0;
			foreach (char cont in P.Nome)
			{
					//if (anterior == ' ')
						//FraseAlternada += cont.ToString().ToUpper();
						
					if (num % 2 == 0)
						FraseAlternada += cont.ToString().ToLower();
				
				
				else 
					FraseAlternada += cont.ToString().ToUpper();
					
				num += 1;
			}
			return FraseAlternada;
		}
}
						
	public string Inverter (string frase)
	{
		string FraseInvertida = string.Empty;
		
		foreach (char cont in frase)
		{
			FraseInvertida = cont + FraseInvertida;
		}
		return FraseInvertida;
	
	}
	
	public bool Palindromo (string frase)
	{
		return Inverter(frase).ToLower() == frase.ToLower();
	}
}

TreinoFocadoC TFC = new TreinoFocadoC ();

string[] ValoresPraFuncoes = new string[10];
ValoresPraFuncoes[1] = "oi tudo bem?";

Console.WriteLine(TFC.FraseComTracinho(ValoresPraFuncoes[1]));

ValoresPraFuncoes[0] = "oieeeeee";
List<int> CodificacaoAscii = TFC.CodigoAscii(ValoresPraFuncoes[0]);

Console.WriteLine(string.Join(" | ", CodificacaoAscii));

ValoresPraFuncoes[2] = "oiié";

Console.WriteLine(TFC.TodasVogais(ValoresPraFuncoes[2]));

Pessoa P1 = new Pessoa();
P1.Nome = "Alex pouse";
P1.Nasc = DateTime.Today;
P1.Cidade = "SP";

string Alternado = TFC.Alternar(P1);

Console.WriteLine(TFC.Alternar(P1));

ValoresPraFuncoes[4] = "Ana";

string Invertendo = TFC.Inverter(ValoresPraFuncoes[4]);

Console.WriteLine(TFC.Inverter(ValoresPraFuncoes[4]));

bool palindromo = TFC.Palindromo(ValoresPraFuncoes[4]);
Console.WriteLine(TFC.Palindromo(ValoresPraFuncoes[4]));
```