FP 2022-11-21

# am_tools.py

import random

# ferramenta genérica de nome
# "inteirosAleatorios"
# para gerar
# coleções de inteiros aleatórios
# entre um mínimo e um máximo,
# em quantidade configurável.

DEFAULT_MIN = 1
DEFAULT_MAX = 50
DEFAULT_Q = 5
DEFAULT_ACCEPT_REP = False

def inteirosAleatorios(
    pMin:int=DEFAULT_MIN,
    pMax:int=DEFAULT_MAX,
    pQ:int=DEFAULT_Q,
    pbAcceptRepetitions:bool=DEFAULT_ACCEPT_REP
):
    colComOsInteiros:list=[]

    iAmplitude:int = pMax-pMin+1
    bPossivelTrabalhar = pQ<=iAmplitude
    if (not bPossivelTrabalhar):
        return colComOsInteiros

    while(len(colComOsInteiros)<pQ):
        i=random.randint(pMin, pMax)
        if(pbAcceptRepetitions):
            colComOsInteiros.append(i)
        else: # rejeitar repetições
            # procurar!
            resultadoDaProcura =\
            procuraGenerica_v3(colComOsInteiros, i)
            bEncontrei = len(resultadoDaProcura)>0
            if(not bEncontrei):
                colComOsInteiros.append(i)
            # if
        # else
    #while
    return colComOsInteiros



def inteirosAleatorios_v0(
    pMin:int=DEFAULT_MIN,
    pMax:int=DEFAULT_MAX,
    pQuantidade:int=DEFAULT_Q,
)->list:
    retorno:list=[] # 0 elementos

    while(len(retorno)<pQuantidade):
        i:int = random.randint(
            pMin,
            pMax
        )
        retorno.append(i)
    return retorno
# def inteirosAleatorios_v0

def procuraGenerica_v0(
    pCol:list, # a coleção / o espaço de dados onde procurar
    pE:int # o elemento a procurar na coleção
)->bool: # retorna True se encontrar pE em pCol; False c.c.
    return pE in pCol
# procuraGenerica_v0

def procuraGenerica_v1(
    pCol:list, # a coleção / o espaço de dados onde procurar
    pE:int # o elemento a procurar na coleção
)->bool: # retorna True se encontrar pE em pCol; False c.c.
    bColVazia = len(pCol)==0
    if (not bColVazia):
        enderecosValidos = range(0, len(pCol))
        for passeio in enderecosValidos:
            quemResideNoEndereco = pCol[passeio]
            bEncontreiOQueProcuro =\
                pE == quemResideNoEndereco
            if (bEncontreiOQueProcuro):
                return True # termina a função
            # if
        # for
    else:
        # se vazia, não tem elementos
        return False # uma col vazia não tem els
    # if-else

    return False
# procuraGenerica_v1

def procuraGenerica_v2(pCol, pE)->True:
    for el in pCol:
        if(el==pE):
            return True
        # if
    # for
    return False
# def procuraGenerica_v2

def procuraGenerica_v3(pCol, pE)->list:
    enderecosEmQueSeEncontra = list()
    for endereco in range(0, len(pCol)):
        el = pCol[endereco]
        bEncontrei = el==pE
        if(bEncontrei):
            enderecosEmQueSeEncontra.append(endereco)
        #if
    # for
    return enderecosEmQueSeEncontra
# def procuraGenerica_v3

"""
Escreva uma função de nome numComXDigitos
que, recebidos um número pN, e uma quantidade
de digitos pD
retorna uma string q representa
o número com pD digitos
Exemplo:
numComXDigitos(pN=2, pD=4)
"0002"
"""
def numComXDigitos(pN, pD):
    strRet = str(pN) #"333"

    bCautela = len(strRet)<=pD

    if (bCautela):
        while(len(strRet)<pD):
            strRet="0"+strRet
        #while
    # if
    return strRet
# def numComXDigitos


**************************************************

# em10.py
# em9.py

from am_tools import *

KEY_NUMS = "nums"
KEY_STARS = "estrelas"

apostaEM = dict()
apostaEM = {}

apostaEM = {
    "nums":[],
    "estrelas":[]
}
print(apostaEM)


apostaEM = {
    "nums":inteirosAleatorios(1, 50, 5, pbAcceptRepetitions=False),
    "estrelas":inteirosAleatorios(1, 10, 2, False)
}
print(apostaEM)

nums = inteirosAleatorios(
    pMin=1,
    pMax=50,
    pQ=5,
    pbAcceptRepetitions=False)

# forma equivalente, que confia em valores por defeito
#nums = inteirosAleatorios()

stars = inteirosAleatorios(
    pMin=1,
    pMax=10,
    pQ=2,
    pbAcceptRepetitions=False)

#operando esquerdo objeto do tipo lista
#operando direito é o comportamento de "sort"
#objeto.comportamento()
nums.sort() # sorting in-place
stars.sort() # sorting in-place

apostaEM = {
    "nums": nums,
    "estrelas": stars
}
print(apostaEM)

"""
Escreva uma função de nome
obterColecaoEMApostasSimples
que, recebendo uma quantidade de apostas,
retorna uma coleção de apostas de EM,
aleatórias.
"""

def obterColecaoEMApostasSimples\
    (pQ:int)->list:

    col:list = list()
    #col = []
    for contadorDeAposta in range(pQ):
        #print(contadorDeAposta)
        #aposta = dict()
        nums = inteirosAleatorios(1,50,5,False)
        estrelas = inteirosAleatorios(1,10,2,False)
        nums.sort()
        estrelas.sort()
        aposta = {
            KEY_NUMS:nums,
            KEY_STARS:estrelas, # trailing comma
        }
        col.append(aposta)
    # for

    return col
# def obterColecaoEMApostasSimples

def apresentarColDeApostasEM_v0(pCol):
    for a in pCol:
        print(a)
    # for
# def apresentarColDeApostasEM_v0

def apresentarColDeApostasEM_v1(pCol):
    # cada a é um dict que vive numa list
    contadorDeApostas = 1
    for a in pCol:
        nums = a[KEY_NUMS]
        stars = a[KEY_STARS]
        strNums = ""
        strStars = ""
        for n in nums:
            strNums += str(n)+" "
        # for
        for n in stars:
            strStars += str(n) + " "
        # for

        strAposta = f"Aposta #{contadorDeApostas}: "
        strAposta+=f" números: {strNums} "
        strAposta+= f" estrelas: {strStars}"
        print(strAposta)
        contadorDeApostas+=1

    # for
# def apresentarColDeApostasEM_v1

def apresentarColDeApostasEM_v2(pCol):
    # cada a é um dict que vive numa list
    contadorDeApostas = 1
    for a in pCol:
        nums = a[KEY_NUMS]
        stars = a[KEY_STARS]
        strNums = ""
        strStars = ""
        for n in nums:
            strNums += numComXDigitos(n, 2)+" "
        # for
        for n in stars:
            strStars += numComXDigitos(n, 2) + " "
        # for

        strAposta = f"Aposta #{numComXDigitos(contadorDeApostas,2)}: "
        strAposta+=f" números: {strNums} "
        strAposta+= f" estrelas: {strStars}"
        print(strAposta)
        contadorDeApostas+=1

    # for
# def apresentarColDeApostasEM_v2

#print(numComXDigitos(2, 10)) # 002
#print(numComXDigitos(333, 1)) # 333

"""
Escreva um função de nome loadApostas
capaz de retornar uma coleção de apostas EM
a partir de um ficheiro de texto
no seguinte formato:
- uma aposta por linha terminada em \n
- cada aposta tem primeiro os números, depois as estrelas
- os números estão separados das estrelas por \t
- os números que compõem as sequência estão separados pelo
espaço em branco
"""

def loadApostas(pNomeDoFicheiro:str):
    ret:list=[]
    try:
        fr = open(pNomeDoFicheiro, 'rt')
        conteudoDoFicheiro:str = fr.read()
        linhas = conteudoDoFicheiro.split("\n")
        fr.close()

        for linha in linhas:
            strippedLinha = linha.strip()
            if(strippedLinha!=""):
                duasPartes = strippedLinha.split("\t")
                bCautela = len(duasPartes)==2
                if (bCautela):
                    strNums = duasPartes[0]
                    strStars = duasPartes[1]
                    listStrNums = strNums.split(" ")
                    listStrStars = strStars.split(" ")
                    listNums = []
                    listStars = []
                    for strNum in listStrNums:
                        listNums.append(int(strNum))
                    # for

                    for strStar in listStrStars:
                        listStars.append(int(strStar))
                    # for

                    listNums.sort()
                    listStars.sort()

                    dictAposta = {
                        KEY_NUMS:listNums,
                        KEY_STARS:listStars
                    }
                    ret.append(dictAposta)
                # if cautela
            # if linha com aposta
        # para cada linha

        #print(conteudoDoFicheiro)
    # try
    except Exception as e:
        print(str(e))
    # try-except

    return ret
# def loadApostas

FICH_TESTE = "apostas_favoritas.txt"
col = loadApostas(FICH_TESTE)
print(col)

"""
Escreva uma função de nome
classificaApostas
que, recebidas duas coleções,
pApostas
pChave
classifica cada uma das apostas em pApostas
relativamente à chave em pChave
respondendo uma coleção de tuplos
(#acertos-números, #acertos-estrelas)
que medem as coincidências entre
cada aposta e a chave

"""
def classificaAposta(pA:dict, pC:dict):
    numsAposta = pA[KEY_NUMS]
    starsAposta = pA[KEY_STARS]
    numsChave = pC[KEY_NUMS]
    starsChave = pC[KEY_STARS]

    setNumsAposta:set = set(numsAposta)
    setStarsAposta:set = set(starsAposta)
    setNumsChave:set = set(numsChave)
    setStarsChave:set = set(starsChave)

    acertosDeNumeros =len(
        setNumsAposta.intersection(setNumsChave)
    )
    acertosDeEstrelas = len(
        setStarsAposta.intersection(setStarsChave)
    )
    return (acertosDeNumeros, acertosDeEstrelas)
# def classificaAposta

def classificaApostas(
    pApostas:list,
    pChave:dict
)->list:
    ret = []
    for aposta in pApostas:
        r=classificaAposta(aposta, pChave)
        ret.append(r)
    #for
    return ret
# def classificaApostas


CHAVE = {
    KEY_NUMS:[3,22,27,30,42],
    KEY_STARS:[6,7]
}
print(classificaApostas(col, CHAVE))**********************


03 06 17 32 47	04 10
08 14 19 27 40	07 08
05 09 18 20 37	03 09
11 22 28 34 49	06 07
05 06 14 33 38	01 02
14 19 25 37 48	06 09
03 12 35 40 42	01 03
01 06 16 24 32	04 10
08 18 38 42 50	02 04
06 14 19 27 35	03 10