/*Defina o mtodo Calculadora que, dados dois valores, devolve a soma, a subtrao, o

produto e a diviso deles. Dever ainda, caso alguma operao possa correr mal, devolver
false,
caso contrrio dever devolver true.*/
public static bool Calculadora(int valorOne, int valorTwo, out int soma,
out int sub, out int mut, out int divi, out int resto)
{
bool verdade = true;
soma = valorOne + valorTwo;
sub = valorOne - valorTwo;
mut = valorOne * valorTwo;
if (valorTwo == 0)
{
verdade = false;
divi = 0;
resto = 0;
}
else
{
divi = valorOne / valorTwo;
resto = valorOne % valorTwo;
}
return verdade;
}
/*Defina o mtodo MultiplicaMultiplosN que, numa sequncia de 0 a 100, calcu
la o
produto dos 4 primeiros valores que sejam mltiplos de N. Por exemplo, no caso em
que N=7,
i.e., MultiplicaMultiplosN(7), dever devolver o produto dos 4 primeiros valores e
ntre 0 e 100 que
sejam mltiplos de 7*/
public static int MultiplicaMultiplosN(int a)
{
int cont=0;
int resultado = 1;
for (int i = 1; i <= 100; i++)
{
if (i % a == 0 && cont < 4)
{
resultado = resultado * i;
cont++;
}
}
return resultado;
}
/*Defina um mtodo ValidaNumero que, ao receber um valor numrico em formato

de
texto, verifica se esse valor se encontra numa determinada gama de valores. Caso
se verifique,
devolve verdade e esse valor numrico. Caso contrrio, devolve falso.*/
public static bool ValidaNumero(string a, out int valorNumerico)
{
int result;
bool verdade = false;
valorNumerico=0;
bool teste=int.TryParse(a, out result);
if (teste == true)
{
verdade = true;
valorNumerico = result;
}
return verdade;
}
/*Defina o mtodo GetDateValues que, dado o valor de uma data, devolve os
valores
do Dia, Ms e Ano. Dever ainda verificar se o ano bissexto ou no. O algoritmo da frmu
la de
clculo de um ano bissexto pode ser representado por:*/
public static bool GetDateValues(DateTime a, out int dia, out int mes, o
ut int ano)
{
dia = a.Day;
mes = a.Month;
ano = a.Year;
bool bissexto=false;
if(a.Year%400==0)
{
bissexto=true;
}
if (a.Year % 4 == 0 && a.Year % 100 != 0)
{
bissexto = true;
}
else
{
bissexto = false;
}
return bissexto;
}
/* Defina o mtodo de instncia CalcOper que, dados dois valores e um operad
or,
devolve: i) o resultado do clculo da operao sobre os valores de entrada e ii) Verda
deiro ou
Falso consoante a operao se realizou bem ou no. Deve contemplar pelo menos as 4
operaes bsicas (+, -, *, /). Exemplos:*/
public static bool CalcOper(double a, double b, char op, out double tota
l)
{
bool verdade = false;
total = 0;
if (op == '+')

{
total = a + b;
verdade = true;
return verdade;
}
if (op == '-')
{
total = a - b;
verdade = true;
return verdade;
}
if (op == '*')
{
total = a * b;
verdade = true;
return verdade;
}
if (op == '/')
{
if (b == 0)
{
total = 0;
verdade = false;
return verdade;
}
else
{
total = a / b;
verdade = true;
return verdade;
}
}
if (op == '%')
{
if (b == 0)
{
total = 0;
verdade = false;
return verdade;
}
else
{
total = a % b;
verdade = true;
return verdade;
}
}
return verdade;
}
/*Defina o mtodo de instncia GetAllValues que, dado um texto e um array de
strings
(so indiferentes maisculas e minsculas), realiza as seguintes operaes:

i) Verifica se esse texto existe nesse array

ii) Devolve todas as posies onde esse texto exista
iii) Devolve quantas posies do array no contm esse texto*/
public static bool GetAllValues(string[] dado,string d, out int[] local,
out int totLocal)
{
int cont=0;
int go=0;
bool existe=false;
for (int i = 0; i < dado.Length; i++)
{
if (dado[i] == d)
{
existe = true;
cont++;
}
}
totLocal = dado.Length - cont;
local = new int[cont];
for (int i = 0; i < dado.Length; i++)
{
if (dado[i] == d)
{
local[go++] = i;
}
}
return existe;
}
/*Defina o mtodo de classe GetArrayNotCommonValues que, dados dois arrays
,
devolve um novo array com a unio dos valores que no so comuns aos dois arrays inici
ais*/
public static int[] GetArrayNotCommonValues(int[] a, int[] b)
{
int posicoes = 0;
for (int i = 0; i < a.Length; i++)
{
for (int j = 0; j < b.Length; j++)
{
if (a[i] == b[j])
{
break;
}
if (j == b.Length - 1)
{
posicoes++;
}
}
}
for (int i = 0; i < b.Length; i++)
{
for (int j = 0; j < a.Length; j++)
{
if (b[i] == a[j])

{
break;
}
if (j == a.Length - 1)
{
posicoes++;
}
}
}
int[] final = new int[posicoes];// definido o tamanho do array fazen
do a contagem dos valores diferentes
int pos = 0;
for (int i = 0; i < a.Length; i++)
{
for (int j = 0; j < b.Length; j++)
{
if (a[i] == b[j])
{
break;
}
if (j == b.Length - 1)
{
final[pos] = a[i];
pos++;
}
}
}
for (int i = 0; i < b.Length; i++)
{
for (int j = 0; j < a.Length; j++)
{
if (b[i] == a[j])
{
break;
}
if (j == a.Length - 1)
{
final[pos] = b[i];
pos++;
}
}
}
return final;
}
/*Descubra a forma de implementar, e implemente, um mtodo capaz de devolv
er o maior dos
parmetros inseridos: Exemplos:*/
public static int Max(params int[] a)
{
int aux = int.MinValue;

for (int i = 0; i < a.Length; i++)

{
if (aux < a[i])
{
aux = a[i];
}
}
return aux;
}
/*Defina o mtodo de instncia ContaTransformaPositivos que, dado um array de valore
s
numricos, devolva o nmero de valores que so positivos Aos valores que so negativos
transforma-os em positivos*/
public static int ContaTransformaPositivos(int[] dado, out int[] novo)
{
int p = 0;
for (int i = 0; i < dado.Length; i++)
{
if (dado[i] >= 0)
{
p++;
}
}
for (int i = 0; i < dado.Length; i++)
{
if (dado[i] < 0)
{
dado[i] = -dado[i];
}
}
novo = dado;
return p;
}
/*Defina o mtodo instncia GetDaysOfYear que, dada uma data como string, verifica s
e vlida ou
no. Caso seja vlida devolve o nmero de dias desse ano. Caso contrrio devolve
o ano 0.*/
public static int GetDaysOfYear(string a)
{
int devolve=0;
int ano;
DateTime resultante;
bool teste = DateTime.TryParse(a, out resultante);
if (teste == true)
{
ano = resultante.Year;
DateTime find = new DateTime(ano, 12, 31);
devolve = find.DayOfYear;
}

return devolve;
}
/*Defina o mtodo de instncia SomaSoPositivos que, dado um array de valores numrico
s, devolva
a soma apenas dos que so positivos.*/
public static int SomaSoPositivos(int[] dado)
{
int soma = 0;
for (int i = 0; i < dado.Length; i++)
{
if (dado[i] > 0)
{
soma = soma + dado[i];
}
}
return soma;
}
/*Defina o mtodo instncia GetYearDate que verifica se uma data vlida ou no. Caso sej
a vlida
e corresponda a um ano Bissexto, devolve tambm o ano dessa data. Caso contrrio dev
olve o
ano -1 .*/
public static bool GetYearDate(string a, out int ano)
{
bool bissexto = false;
ano = -1;
DateTime testado;
bool teste = DateTime.TryParse(a, out testado);
if (teste == true)
{
if (testado.Year % 400 == 0)
{
bissexto = true;
ano = testado.Year;
}
if (testado.Year % 4 == 0 && testado.Year % 100 != 0)
{
bissexto = true;
ano = testado.Year;
}
}
return bissexto;
}

/*Defina o mtodo de instncia GetNextDateElements que verifica se uma string

corresponde a uma data vlida ou no. Caso seja vlida, dever devolver tambm o ano segui
nte e
o ms seguinte dessa data. Caso contrrio devolver Falso. Parte da sintaxe deste mtodo
poder
ser:*/
public static bool GetNextDateElements(string a, out int ano, out int me
s)
{
bool valido = false;
ano = int.MinValue;
mes = int.MaxValue;
DateTime resultante;
bool teste = DateTime.TryParse(a, out resultante);
if (teste == true)
{
valido = true;
ano = resultante.Year + 1;
mes = resultante.Month + 1;
}
return valido;
}
/*Defina um mtodo SerializeArray que, remove os valores repetidos num arr
ay. O array
resultante deve ser ordenado. A ordenao poder ser crescente ou decrescente. Parte d
a sintaxe
deste mtodo poder ser:*/
public static int[] SerializeArray(int[] one)
{
int cont = 0;
int[] novo;
int numero = 0;
//sabe quantos so diferentes
for (int i = 0; i < one.Length - 1; i++)
{
if (one[i] == one[i + 1])
numero = one[i];
else if (one[i] != one[i + 1])
{
cont++; // i = a dimenso menos 2 pois a ultima iterao
if (i == one.Length - 2 && (one.Length - 1 != one.Length - 2
))
{
cont++;
break;
}
continue;
}
if (numero == one[i] && i == one.Length - 2)
{
cont++;
break;
}

}
novo = new int[cont];
cont = 0;
//meteos numa array nova
for (int i = 0; i < one.Length - 1; i++)
{
if (one[i] == one[i + 1])
numero = one[i];
if (i == one.Length - 2 && (one.Length - 1 != one.Length - 2) ||
one[i] != one[i + 1])
{
if (one[i] != one[i + 1])
{
novo[cont] = one[i];
cont++;
}
if (i == one.Length - 2 && (one.Length - 1 != one.Length - 2
))
{
novo[cont] = one[i + 1];
cont++;
continue;
}
}
if (numero == one[i] && i == one.Length - 2)
{
novo[cont] = one[i];
break;
}
}
int t;
for (int i = 0; i < novo.Length; i++)
{
for (int y = i; y < novo.Length; y++)
{
if (novo[i] > novo[y])
{
t = novo[i];
novo[i] = novo[y];
novo[y] = t;
}
}
}
return novo;
}
/*Desenvolva um projeto TesteG2 no qual implemente o mtodo Executa de tal
forma que:
a) Dado um conjunto de trs parmetros (Executa (p1, p2, p3)), o mtodo consegue d

evolver os
seguintes resultados:
? Caso p2 seja o smbolo * , executa a multiplicao dos restantes parmetros
? Caso p2 seja o smbolo > devolve o maior entre o primeiro e o terceiro parmetro
? Caso p2 seja o smbolo ^ executa a potncia do primeiro levantado ao terceiro pa
rmetro (p1 p3)
? Caso p2 seja o smbolo U concatena o primeiro ao terceiro parmetro. Por exemplo
, as instrues
seguintes dariam como resultados:*/
public static double Executa(string p1, string p2, string p3, out bool f
inal, out string uni)
{
int tot=0;
int pp1;
int pp3;
double oj;
uni = "";
final = false;
bool dasd=int.TryParse(p1,out pp1);
bool dasd1 = int.TryParse(p3, out pp3);
if (p2 == "*" && dasd == true && dasd1 == true)
{
final = true;
return tot = pp1 * pp3;
}
else
{
tot = 0;
final = false;
}
if (p2 == ">" && dasd == true && dasd1 == true)
{
if (pp1 > pp3)
{
final = true;
return pp1;
}
else
{
final = true;
return pp3;
}
}

if (p2 == "^" && dasd == true && dasd1 == true)

{
final = true;
oj=Math.Pow(pp1, pp3);
return oj;
}
if (p2 == "U")
{
final = true;
uni = p1 + p3;
}
return tot;
}