Example #1
0
        private static Gabarito[] GerarGabaritosSomador(int quantidadeBits)
        {
            var quantidadeBitsResultado = quantidadeBits + 1;
            var gabaritos      = new Gabarito[quantidadeBitsResultado];
            var entradaMáxima  = (int)Math.Pow(2, quantidadeBits) - 1;
            var índiceGabarito = 0;

            for (int i = 0; i < quantidadeBitsResultado; i++)
            {
                gabaritos[i] = new Gabarito();
            }

            for (int i = 0; i <= entradaMáxima; i++)
            {
                for (int e = 0; e <= entradaMáxima; e++)
                {
                    var resultado = new ArrayBits(quantidadeBitsResultado);
                    resultado.PreencherAPartirNumero(i + e);
                    foreach (var item in resultado.Bits)
                    {
                        gabaritos[índiceGabarito].AdicionarEntrada(item);
                        índiceGabarito++;
                    }
                    índiceGabarito = 0;
                }
            }

            return(gabaritos);
        }
Example #2
0
        private Resultado GerarNumeros(Gabarito gabarito)
        {
            List <int> lista = new List <int>();

            IEnumerable <int> dezenas1 = null;
            IEnumerable <int> dezenas2 = null;
            IEnumerable <int> dezenas3 = null;
            IEnumerable <int> dezenas4 = null;
            IEnumerable <int> dezenas5 = null;
            IEnumerable <int> dezenas6 = null;
            IEnumerable <int> dezenas7 = null;

            GerarDezena1(gabarito, ref dezenas1);
            GerarDezena2(gabarito, ref dezenas2);
            GerarDezena3(gabarito, ref dezenas3);
            GerarDezena4(gabarito, ref dezenas4);
            GerarDezena5(gabarito, ref dezenas5);
            GerarDezena6(gabarito, ref dezenas6);
            GerarDezena7(gabarito, ref dezenas7);


            lista.AddRange(dezenas1.Select(x => x));
            lista.AddRange(dezenas2.Select(x => x));
            lista.AddRange(dezenas3.Select(x => x));
            lista.AddRange(dezenas4.Select(x => x));
            lista.AddRange(dezenas5.Select(x => x));
            lista.AddRange(dezenas6.Select(x => x));
            lista.AddRange(dezenas7.Select(x => x));


            //Fix this - Zebra!
            while (lista.Count < 6)
            {
                lista.Add(GetRandomNumber(1, 60));
            }

            lista.Sort();

            Resultado res = new Resultado();

            res.Dezena1 = lista[0].ToString();
            res.Dezena2 = lista[1].ToString();
            res.Dezena3 = lista[2].ToString();
            res.Dezena4 = lista[3].ToString();
            res.Dezena5 = lista[4].ToString();
            res.Dezena6 = lista[5].ToString();


            dezenas1 = null;
            dezenas2 = null;
            dezenas3 = null;
            dezenas4 = null;
            dezenas5 = null;
            dezenas6 = null;
            dezenas7 = null;


            return(res);
        }
Example #3
0
        private void GerarDezena1(Gabarito gabarito, ref IEnumerable <int> dezenas1)
        {
            do
            {
                dezenas1 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x < 10)
                           .Skip(GetRandomNumber(RAND_MIN, RAND_MAX))
                           .Take(gabarito.Quantidade1)
                           .ToList();

                RAND_MAX++;
            } while (gabarito.Quantidade1 != dezenas1.Count());
        }
Example #4
0
        public async Task <IActionResult> Post(Gabarito gabarito)
        {
            try
            {
                _repositorio.Add(gabarito);

                if (await _repositorio.SaveChangesAsync())
                {
                    return(Ok(gabarito));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest($"Erro: {ex.Message}"));
            }
            return(BadRequest());
        }
Example #5
0
        public Gabarito Executar(CadastrarGabaritoDto cadastrarGabaritoDto)
        {
            var prova = ValidarProva(cadastrarGabaritoDto);

            ValidarQuestoesRespostas(cadastrarGabaritoDto, prova);
            ValidarAlernativas(cadastrarGabaritoDto);

            var respostas = cadastrarGabaritoDto.Respostas.Select(x => new Respostas
            {
                NumeroQuestao = x.NumeroQuestao,
                Alternativa   = x.Alternativa,
            }).ToList();

            var gabarito = new Gabarito
            {
                IdProva   = cadastrarGabaritoDto.IdProva,
                Respostas = respostas
            };

            Dados.Gabaritos.Add(gabarito);

            return(gabarito);
        }
Example #6
0
        public async Task <IActionResult> Put(int gabaritoId, Gabarito gabarito)
        {
            try
            {
                var gabaritoCadastrado = await _repositorio.GetGabaritoById(gabaritoId);

                if (gabaritoCadastrado == null)
                {
                    return(NotFound());
                }
                _repositorio.Update(gabaritoCadastrado);

                if (await _repositorio.SaveChangesAsync())
                {
                    return(Ok(gabarito));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest($"Erro: {ex.Message}"));
            }
            return(BadRequest());
        }
Example #7
0
        private Resultado GerarNumeros2(Gabarito gabarito)
        {
            List <int> lista = new List <int>();

            // 1 - 9
            var dezenas1 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x < 10)
                           .Take(gabarito.Quantidade1);

            // 10 - 19
            var dezenas2 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 9 && x < 20)
                           .Take(gabarito.Quantidade2);

            // 20 - 29
            var dezenas3 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 19 && x < 30)
                           .Take(gabarito.Quantidade3);

            // 30 - 39
            var dezenas4 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 29 && x < 40)
                           .Take(gabarito.Quantidade4);

            // 40 - 49
            var dezenas5 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 39 && x < 50)
                           .Take(gabarito.Quantidade5);

            // 50 - 59
            var dezenas6 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 49 && x < 60)
                           .Take(gabarito.Quantidade6);

            // 60 - 69
            var dezenas7 = listaNumerosResultados.GroupBy(x => x)
                           .OrderByDescending(g => g.Count())
                           .Select(g => g.Key)
                           .Where(x => x > 59 && x < 70)
                           .Take(gabarito.Quantidade7);


            lista.AddRange(dezenas1.Select(x => x));
            lista.AddRange(dezenas2.Select(x => x));
            lista.AddRange(dezenas3.Select(x => x));
            lista.AddRange(dezenas4.Select(x => x));
            lista.AddRange(dezenas5.Select(x => x));
            lista.AddRange(dezenas6.Select(x => x));
            lista.AddRange(dezenas7.Select(x => x));


            Resultado res = new Resultado();

            res.Dezena1 = lista[0].ToString();
            res.Dezena2 = lista[1].ToString();
            res.Dezena3 = lista[2].ToString();
            res.Dezena4 = lista[3].ToString();
            res.Dezena5 = lista[4].ToString();
            res.Dezena6 = lista[5].ToString();


            return(res);
        }
Example #8
0
        private void GerarNumeros()
        {
            ClearGridJogosGerados();


            var mostCommon = listaNumerosResultados.GroupBy(x => x)
                             .OrderByDescending(g => g.Count())
                             .Select(g => g.Key);


            var jogoMaisComum = listaNumerosResultados.GroupBy(x => x)
                                .OrderByDescending(g => g.Count())
                                .Select(g => g.Key).Take(6);



            int    qtd    = int.Parse(txtQtdJogos.Text);
            string gabNum = ((DataRowView)checkedListBoxGabaritos.CheckedItems[0])["Numero"].ToString();

            Gabarito ga = listaGabaritos.Where(x => x.Numero == int.Parse(gabNum)).First();

            int i     = 0;
            int media = int.Parse(txtMediaSoma.Text);

            while (i != qtd)
            {
                Application.DoEvents();

                AddToLog(string.Format("Tentando Gerar jogo número: {0}", i + 1));
                Resultado res = GerarNumeros(ga);


                int start = media - GetDesvioMedia();
                int qty   = ((media + GetDesvioMedia()) - start) + 1;

                IEnumerable <int> rangeMediaSomaDosResultados = Enumerable.Range(start, qty);

                //O  jogo gerado: já não foi gerado, está dentro da média e não foi sorteado ainda
                var jaFoiGerado = jogosGerados.Where(x => x.Dezena1 == res.Dezena1 &&
                                                     x.Dezena2 == res.Dezena2 &&
                                                     x.Dezena3 == res.Dezena3 &&
                                                     x.Dezena4 == res.Dezena4 &&
                                                     x.Dezena5 == res.Dezena5 &&
                                                     x.Dezena6 == res.Dezena6).Count() > 0;

                var estaDentroDaMedia = rangeMediaSomaDosResultados.Contains(res.Soma);

                var jogoJaFoisorteado = JogoJaFoiSorteado(res);


                if (!jaFoiGerado && estaDentroDaMedia && !jogoJaFoisorteado)
                {
                    jogosGerados.Add(res);
                    i++;
                    AddToLog(string.Format("Sucesso!!! jogo número: {0} gerado", i));
                }
                else
                {
                    AddToLog(string.Format("Falha! Não atende ao critério: Já gerado: {0} | Media: {1} | Já sorteado: {2}", jaFoiGerado, estaDentroDaMedia, jogoJaFoisorteado));

                    if (!estaDentroDaMedia)
                    {
                        UpdateDesvioMedia();
                    }
                }
            }

            jogosGerados.Sort((x, y) => x.Dezena1.CompareTo(y.Dezena1));



            /*
             * int randomSkip;
             * int randomTake;
             *
             *  randomSkip = GenerateSomeAppropriateRandomNumber();
             *  randomTake = GenerateSomeAppropriateRandomNumber();
             *
             *  resultSet = iEnumerable.Skip(randomSkip).Take(randomTake);
             */
        }