public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var parDaMaoA = _identificadorDePar.IdentificarCartas(maoA);
var parDaMaoB = _identificadorDePar.IdentificarCartas(maoB);
if (parDaMaoA.First().Valor != parDaMaoB.First().Valor)
{
return(parDaMaoA.First().Valor > parDaMaoB.First().Valor ? maoA : maoB);
}
var restanteDaMaoA = maoA.Where(carta => !parDaMaoA.Contains(carta)).ToList();
var restanteDaMaoB = maoB.Where(carta => !parDaMaoB.Contains(carta)).ToList();
Carta cartaMaisAltaDaMaoA;
Carta cartaMaisAltaDaMaoB;
do
{
if (restanteDaMaoA.Count == 0 || restanteDaMaoB.Count == 0)
{
return(new List <Carta>());
}
cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta.IdentificarCartas(restanteDaMaoA).First();
cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta.IdentificarCartas(restanteDaMaoB).First();
restanteDaMaoA.Remove(cartaMaisAltaDaMaoA);
restanteDaMaoB.Remove(cartaMaisAltaDaMaoB);
} while (cartaMaisAltaDaMaoB.Valor == cartaMaisAltaDaMaoA.Valor);
return(cartaMaisAltaDaMaoA.Valor > cartaMaisAltaDaMaoB.Valor ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var umaCartaDaQuadraA = _identificadorDeQuadra.IdentificarCartas(maoA).First();
var umaCartaDaQuadraB = _identificadorDeQuadra.IdentificarCartas(maoB).First();
return(umaCartaDaQuadraA.Valor > umaCartaDaQuadraB.Valor ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var trincaDaMaoA = _identificadorDeTrinca.IdentificarCartas(maoA);
var trincaDaMaoB = _identificadorDeTrinca.IdentificarCartas(maoB);
var somaDaTrincaDaMaoA = trincaDaMaoA.Sum(carta => carta.Valor);
var somaDaTrincaDaMaoB = trincaDaMaoB.Sum(carta => carta.Valor);
return(somaDaTrincaDaMaoA > somaDaTrincaDaMaoB ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta.IdentificarCartas(maoA).First();
var cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta.IdentificarCartas(maoB).First();
if (cartaMaisAltaDaMaoA.Valor == cartaMaisAltaDaMaoB.Valor)
{
return(new List <Carta>());
}
return(cartaMaisAltaDaMaoA.Valor > cartaMaisAltaDaMaoB.Valor ? maoA : maoB);
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
var trinca = _identificadorDeTresCartasComValoresIguais.IdentificarCartas(maoDe5Cartas);
var aMaoPossuiUmaTrinca = trinca.Count() == 3;
return(aMaoPossuiUmaTrinca ? trinca : new List <Carta>());
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
var umPar = _identificadorDePares.IdentificarCartas(maoDe5Cartas);
var restanteDaMao = maoDe5Cartas.Where(carta => !umPar.Contains(carta)).ToList();
var outroPar = _identificadorDePares.IdentificarCartas(restanteDaMao);
var encontrouDoisPares = umPar.Count == 2 && outroPar.Count == 2;
var doisPares = new List <Carta>();
if (encontrouDoisPares)
{
doisPares.AddRange(umPar);
doisPares.AddRange(outroPar);
}
return(doisPares);
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
var flush = _identificadorDeNaipesIguais.IdentificarCartas(maoDe5Cartas);
var straightFlush = _identificadorDeSequencia.IdentificarCartas(flush);
var encontrouUmStraightFlushValido = straightFlush.Count == 5;
return(encontrouUmStraightFlushValido ? straightFlush : new List <Carta>());
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
Carta cartaMaisAltaDaMaoA;
Carta cartaMaisAltaDaMaoB;
var copiaDaMaoA = maoA.Select(carta => carta).ToList();
var copiaDaMaoB = maoB.Select(carta => carta).ToList();
do
{
cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta.IdentificarCartas(copiaDaMaoA).First();
cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta.IdentificarCartas(copiaDaMaoB).First();
copiaDaMaoA.Remove(cartaMaisAltaDaMaoA);
copiaDaMaoB.Remove(cartaMaisAltaDaMaoB);
if (copiaDaMaoA.Count == 0 || copiaDaMaoB.Count == 0)
{
return(new List <Carta>());
}
} while (cartaMaisAltaDaMaoA.Valor == cartaMaisAltaDaMaoB.Valor);
return(cartaMaisAltaDaMaoA.Valor > cartaMaisAltaDaMaoB.Valor ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var trincaDaMaoA = _identificadorDeTrinca.IdentificarCartas(maoA);
var trincaDaMaoB = _identificadorDeTrinca.IdentificarCartas(maoB);
var valorDaJogadaDaMaoA = trincaDaMaoA.Sum(carta => carta.Valor);
var valorDaJogadaDaMaoB = trincaDaMaoB.Sum(carta => carta.Valor);
if (valorDaJogadaDaMaoA == valorDaJogadaDaMaoB)
{
var cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta
.IdentificarCartas(maoA.Where(carta => !trincaDaMaoA.Contains(carta)).ToList())
.First();
var cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta
.IdentificarCartas(maoB.Where(carta => !trincaDaMaoB.Contains(carta)).ToList())
.First();
valorDaJogadaDaMaoA = cartaMaisAltaDaMaoA.Valor;
valorDaJogadaDaMaoB = cartaMaisAltaDaMaoB.Valor;
}
return(valorDaJogadaDaMaoA > valorDaJogadaDaMaoB ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta.IdentificarCartas(maoA).First();
var cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta.IdentificarCartas(maoB).First();
var restanteDaMaoA = maoA.Where(carta => carta.HashDaCarta != cartaMaisAltaDaMaoA.HashDaCarta).ToList();
var restanteDaMaoB = maoB.Where(carta => carta.HashDaCarta != cartaMaisAltaDaMaoB.HashDaCarta).ToList();
while (cartaMaisAltaDaMaoA.Valor == cartaMaisAltaDaMaoB.Valor)
{
if (restanteDaMaoA.Count == 0 || restanteDaMaoB.Count == 0)
{
return(new List <Carta>());
}
cartaMaisAltaDaMaoA = _identificadorDeCartaMaisAlta.IdentificarCartas(restanteDaMaoA).First();
cartaMaisAltaDaMaoB = _identificadorDeCartaMaisAlta.IdentificarCartas(restanteDaMaoB).First();
restanteDaMaoA.Remove(cartaMaisAltaDaMaoA);
restanteDaMaoB.Remove(cartaMaisAltaDaMaoB);
}
return(cartaMaisAltaDaMaoA.Valor > cartaMaisAltaDaMaoB.Valor ? maoA : maoB);
}
public IEnumerable <Carta> Desempatar(IEnumerable <Carta> maoA, IEnumerable <Carta> maoB)
{
var umParDaMaoA = _identificadorDePar.IdentificarCartas(maoA);
var restanteDaMaoA = maoA.Where(carta => !umParDaMaoA.Contains(carta)).ToList();
var outroParDaMaoA = _identificadorDePar.IdentificarCartas(restanteDaMaoA);
var umParDaMaoB = _identificadorDePar.IdentificarCartas(maoB);
var restanteDaMaoB = maoB.Where(carta => !umParDaMaoB.Contains(carta)).ToList();
var outroParDaMaoB = _identificadorDePar.IdentificarCartas(restanteDaMaoB);
var parAltoDaMaoA = umParDaMaoA.First().Valor > outroParDaMaoA.First().Valor ? umParDaMaoA : outroParDaMaoA;
var parAltoDaMaoB = umParDaMaoB.First().Valor > outroParDaMaoB.First().Valor ? umParDaMaoB : outroParDaMaoB;
if (parAltoDaMaoA.First().Valor != parAltoDaMaoB.First().Valor)
{
return(parAltoDaMaoA.First().Valor > parAltoDaMaoB.First().Valor ? maoA : maoB);
}
var parBaixoDaMaoA = umParDaMaoA.First().Valor < outroParDaMaoA.First().Valor ? umParDaMaoA : outroParDaMaoA;
var parBaixoDaMaoB = umParDaMaoB.First().Valor < outroParDaMaoB.First().Valor ? umParDaMaoB : outroParDaMaoB;
if (parBaixoDaMaoA.First().Valor != parBaixoDaMaoB.First().Valor)
{
return(parBaixoDaMaoA.First().Valor > parBaixoDaMaoB.First().Valor ? maoA : maoB);
}
var quintaCartaDaMaoA = restanteDaMaoA.Where(carta => !outroParDaMaoA.Contains(carta)).ToList();
var quintaCartaDaMaoB = restanteDaMaoB.Where(carta => !outroParDaMaoB.Contains(carta)).ToList();
if (quintaCartaDaMaoA.First().Valor == quintaCartaDaMaoB.First().Valor)
{
return(new List <Carta>());
}
return(quintaCartaDaMaoA.First().Valor > quintaCartaDaMaoB.First().Valor ? maoA : maoB);
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
var trinca = _identificadorDeTrinca.IdentificarCartas(maoDe5Cartas);
var restanteDasCartas = maoDe5Cartas.Where(carta => !trinca.Contains(carta)).ToList();
var par = _identificadorDePar.IdentificarCartas(restanteDasCartas);
var fullHouse = new List <Carta>();
if (trinca.Count == 3 && par.Count == 2)
{
fullHouse.AddRange(trinca);
fullHouse.AddRange(par);
}
return(fullHouse);
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas) => _identificadorDePar.IdentificarCartas(maoDe5Cartas);
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas) => _identificadorDeCartasComMesmoNaipe.IdentificarCartas(maoDe5Cartas);
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
return(_identificadorDeCartaMaisAlta.IdentificarCartas(maoDe5Cartas));
}
public IEnumerable <Carta> Encontrar(IEnumerable <Carta> maoDe5Cartas)
{
return(_identificadorDeQuatroCartasComValoresIguais.IdentificarCartas(maoDe5Cartas));
}