[ RESOLVIDO ]PODEM ME AJUDAR COM ESSA LÓGICA
const _APOSTA_RESULTADO = [ 12, 16, 19, 32, 33, 57 ]
const APOSTAS =[
{
id: '5a56fd9b-4b1a-4861-8cf3-8e6cbe08984b',
establishmentId: '1',
number_game_result: '97',
numbers: '7,8,11,12,13,20,21,23,29,33,35,40,43,44,49,51,52,55,56,57',
status: 'IN_PROCESSING',
awarded: false,
hits: 0,
namber_bet: 39,
created_at: 2023-05-19T22:02:04.480Z,
updated_at: 2023-05-19T22:02:04.480Z
},
{
id: '79f7ac62-3579-41e6-bdca-c939efc8d8d7',
establishmentId: '1',
number_game_result: '97',
numbers: '5,8,10,11,19,23,25,27,36,38,39,40,41,42,43,46,48,56,59,60',
status: 'IN_PROCESSING',
awarded: false,
hits: 0,
namber_bet: 36,
created_at: 2023-05-19T22:02:02.204Z,
updated_at: 2023-05-19T22:02:02.204Z
},
{
id: 'ac8c9b26-21b6-4fa2-a27b-752722f3ef6d',
establishmentId: '1',
number_game_result: '97',
numbers: '1,8,10,13,18,22,23,24,31,32,35,36,37,38,40,42,44,49,51,57',
status: 'IN_PROCESSING',
awarded: false,
hits: 0,
namber_bet: 37,
created_at: 2023-05-19T22:02:02.973Z,
updated_at: 2023-05-19T22:02:02.973Z
},
{
id: 'bd4c9d82-84fc-4863-a870-50e73f6c0edd',
establishmentId: '1',
number_game_result: '97',
numbers: '2,5,6,11,14,20,21,23,26,29,32,39,41,45,51,52,55,56,57,59',
status: 'IN_PROCESSING',
awarded: false,
hits: 0,
namber_bet: 38,
created_at: 2023-05-19T22:02:03.694Z,
updated_at: 2023-05-19T22:02:03.694Z
}
]
https://www.youtube.com/watch?v=NMeUcCfytbk&ab_channel=HeuderSena
Git: https://github.com/heudersena/game-mega-sena Sobre o array de aposta tenho algo semelhante vindo do banco de dados. Sou bem iniciante e me encontro a 2 dias pesquisando e tentando chegar no seguinte resltado.
Eu preciso passar por cada APOSTAS verificando se no _APOSTA_RESULTADO existe numeros iguais, se existir ir contabilizando. Caso tem acertos, atualizar o campo acertos com a quantidade de acertos!
Se alguem poder me ajudar, juro que fico muito agradecido!!!
Esta estrutura tem um detalhe estranho: é um array no qual cada elemento é outro array, que por sua vez só tem um elemento (o objeto com id, números, etc). Não deveria ser um array de objetos?
Mas enfim, mantendo essa estrutura, a básica ideia é: cada elemento de APOSTAS é outro array, então para cada um eu faço um loop para verificar os acertos.
Aí uso split para separar os números, e verifico se cada um deles está no array de resultados. Algo assim:
for (const elemento of APOSTAS) {
for (const aposta of elemento) { // cada elemento de APOSTAS é outro array, então faço outro for
for (const n of aposta.nambers.split(',')) { // split para separar os números
if (_APOSTA_RESULTADO.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
aposta.acertos++;
}
}
}
}
console.log(APOSTAS);
Outro detalhe, foi erro de digitação ou o nome da propriedade é nambers mesmo? Não deveria ser numbers? Enfim, fiz acima com nambers mesmo...
Claro, se é garantido que cada sub-array só tem uma única aposta, poderia trocar para:
for (const aposta of APOSTAS) {
for (const n of aposta[0].nambers.split(',')) { // split para separar os números
if (_APOSTA_RESULTADO.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
aposta[0].acertos++;
}
}
}
No caso, aposta[0] pega o primeiro elemento do array. Como eu disse, se vc garante que sempre terá somente um, é o suficiente. Mas se puder ter vários, aí é melhor usar a primeira opção acima.
Eu fiz algo bem parecido com o que você disse, mais sem sucesso.
```javascript
import cron from "node-cron"
import { returnLastIdTableGames } from "../utils/returnLastIdTableGames"
import { generateUniqueNumbers } from "../utils/generateUniqueNumbers"
import { insertValueTableGame } from "../utils/insertValueTableGame"
import { calculateBetMetch } from "../utils/calculateBetMetch"
import { prisma } from "../db/database"
import { UpdateValuesTableBet } from "../utils/UpdateValuesTableBet"
import axios from "axios"
let totalNumber: any = []
class CronJobGamer {
static async startGamer(io: any) {
return cron.schedule('3 * * * * *', async () => {
io.emit("__CLEAN__")
// NUMERO UNÍCO GAME
const NEW_NAMBER_GAME = String(await this.FN_GET_NUMBER_GAME())
// BUSCAR ULTIMO ID INSERIDO NA TABELA GAME
const LAST_NAMBER_INSERTED_TABLE_GAME = Number(await this.FN_VERIFY_LAST_INSERT_TABLE_GAMER())
// INSERI NO BANCO DE DADOS
const GAMER = await insertValueTableGame(NEW_NAMBER_GAME, LAST_NAMBER_INSERTED_TABLE_GAME)
const _ID = GAMER?.match_id
// ENVIAR PARA O FRON-END O ID DO GAMER
io.emit("number::aposta", _ID)
console.log(_ID);
const TRANSFORME_STRING_TO_ARRAY = NEW_NAMBER_GAME.split(",").map(n => Number(n))
let _quantity_loop = 0
const resultados: any = [];
TRANSFORME_STRING_TO_ARRAY.forEach((n, i) => {
setTimeout(async () => {
if (totalNumber.length == 6) {
totalNumber = []
} else {
totalNumber.push(n)
io.emit("gamer:total", [...totalNumber])
io.emit("gamer", n)
}
_quantity_loop++
if (_quantity_loop == 6) {
// CALCULAR AS APOSTAS E MOSTRAR AS APOSTAS QUE FORAM PREMIADAS
calculateBetMetch.verifyBetMatch(GAMER).then(async response => {
// const game = NEW_NAMBER_GAME.split(",").map(_R => Number(_R))
const BETS = await prisma.bet.findMany({ where: { number_game_result: String(GAMER?.match_id), awarded: false, status: "IN_PROCESSING" } })
if (BETS.length <= 0) {
io.emit("_GANHADORES_", { resultados: [], bet: false })
return false
}
let correspondencias = 0;
for (const _BET of BETS) {
for (const _RESPONSE of _BET.numbers.split(",").map(_R => Number(_R))) {
if (TRANSFORME_STRING_TO_ARRAY.includes(_RESPONSE)) {
console.log(_RESPONSE);
correspondencias++;
}
}
if (correspondencias >= 1) {
UpdateValuesTableBet.winners(correspondencias, _BET.id).then(items => {
resultados.push({ id: _BET.id, numeros: _BET.numbers, correspondencias, aposta: items });
}).finally(() => {
io.emit("_GANHADORES_", { resultados, bet: true })
})
} else {
UpdateValuesTableBet.losers(_BET.id).then(r => r)
}
}
})
}
}, 3000 * i)
})
})
}
private static async FN_GET_NUMBER_GAME(): Promise {
// Gerar um GAME aleatório que tenha 6 posições
const numbersGame = await generateUniqueNumbers()
// @ts-ignore
const newNumbersGame = numbersGame.toString().slice(",")
return newNumbersGame
}
private static async FN_VERIFY_LAST_INSERT_TABLE_GAMER(): Promise {
// VERIFICAR NA LABELA GAMER O ULTIMO REGISTRO - CASO NÃO TENHA NENHUM O PRIMEIRO É O 1, E A PARTIR DISSO SEMPRE FAZER O INCREMENT +1
const last = await returnLastIdTableGames()
return last
}
}
export { CronJobGamer }
```
Pra debugar seu sistema eu teria que criar esse banco de dados, além de implementar todas essas funções que estão na pasta `utils` (que eu teria que adivinhar o que fazem e quais dados retornam), etc. Desculpe, mas estou sem tempo pra isso.
Enfim, pra vc resolver, eu sugiro deixar o código mais organizado.
Primeiro vc chama tudo que precisa (a função que traz os jogos, outra que traz os resultados, etc).
Depois vc cria uma função que verifica e atualiza os acertos:
```javascript
function verificaAcertos(apostas, resultados) {
for (const aposta of apostas) {
for (const n of aposta[0].nambers.split(',')) { // split para separar os números
if (resultados.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
aposta[0].acertos++;
}
}
}
}
```
Aí, depois que vc já tem as apostas e acertos, vc chama a função:
```javascript
verificaAcertos(array_de_apostas, array_de_resultados);
// aqui o array_de_respostas estará com os acertos atualizados
```
Depois vc continua o que tem que fazer (atualizar os acertos no banco, etc).
const APOSTAS_CONTABILIZADO = APOSTAS.map( aposta => {
aposta[0].acertos = aposta[0].numbers.split(",").reduce(
(accumulator, currentValue) => accumulator + (_APOSTA_RESULTADO.includes(parseInt(currentValue)) ? 1 : 0),
0
)
return aposta
})
console.log(APOSTAS_CONTABILIZADO)
- O map vai executar cada item do array e retornar um novo array
- O split transforma a String em Array (Arrumei o nome da propriedade nambers)
- O Reduce vai acumular o valor de acertos somente se o numero do numbers estiver presente no _APOSTA_RESULTADO
exemplo: https://jsfiddle.net/97y0t5go/15/
Solução: Créditos: tiagomatosweb O MELHOR!!!
const content = BETS.map((o) => {
const numbersArray = o.numbers.split(',').map(n => parseInt(n))
const intersection = numbersArray.filter(n => TRANSFORME_STRING_TO_ARRAY.includes(n))
return {
...o,
hits: intersection.length,
awarded: intersection.length >= 4 ? true : false,
numbersArray,
intersection
}
})