FP 2022-12-05

# EM_v6.py

import random

class EM:
    # membros de dados estáticos (partilhados por todas as instâncias)
    DEFAULT_MIN = 1
    DEFAULT_MAX = 50
    DEFAULT_Q = 5
    DEFAULT_ACCEPT_REP = False

    @staticmethod
    def contadorDeCoincidenciasEntreColecoes(
        pCol1:list,
        pCol2:list
    ):
        iAcertos=0
        iFalhas=0
        listQuaisOsAcertos = list()
        listFalhas = []
        for el1 in pCol1:
            for el2 in pCol2:
                bCoincidencia = el1==el2
                bNotCoincidencia = el1!=el2
                bNotCoincidencia = not bCoincidencia
                if(bCoincidencia):
                    iAcertos+=1
                    listQuaisOsAcertos.append(el1)
                # if
                else: # not da expressao original
                    iFalhas+=1
                    listFalhas.append(el1)
                # if-else

                # estudar
                if (not bCoincidencia):
                    pass
            # for
        # for
        return iAcertos, listQuaisOsAcertos #, iFalhas, listFalhas
    # def contadorDeCoincidenciasEntreColecoes

    # método estático
    @staticmethod
    def colEnquantoFrase(
        pCol:list,
        pSeparador:str=" "
    ):
        r = ""
        pCol.sort() # ordenação ascendente da col recebida
        iUltimoEndereco = len(pCol)-1
        for endereco in range(len(pCol)):
            elemento = pCol[endereco]
            r+=f"{elemento}"

            bUltimoEndereco =\
                endereco == iUltimoEndereco
            if(not bUltimoEndereco):
                r+=f"{pSeparador}"
            # if
        # for
        return r
    # def colEnquantoFrase

    @staticmethod
    def procuraGenerica(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

    @staticmethod
    def inteirosAleatorios(
        # self, # proibido de se usar, pq o método é partilhado por todas as instâncias
        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 = \
                    EM.procuraGenerica(colComOsInteiros, i)
                bEncontrei = len(resultadoDaProcura) > 0
                if (not bEncontrei):
                    colComOsInteiros.append(i)
                # if
            # else
        # while
        return colComOsInteiros

    # membros de dados
    # propriedades / atributos
    # caracterizadores de instâncias da class
    # instâncias da class = vars da class
    def __init__(
        self, # o objeto em construção
        pNumeros=None,
        pEstrelas=None,
        pTitulo:str="",
        pbFavorita:bool=False
    ):
        self.mTitulo = pTitulo
        self.mFavorita = pbFavorita

        if(pNumeros!=None):
            self.mNumeros = pNumeros
        else:
            # decidimos números aleatórios
            self.mNumeros =\
                EM.inteirosAleatorios(
                    EM.DEFAULT_MIN,
                    EM.DEFAULT_MAX,
                    EM.DEFAULT_Q
                )

        if(pEstrelas!=None):
            # m - o meu prefixo para sinalizar "data member" / "membros de dados"
            self.mEstrelas = pEstrelas
        else:
            # decidimos estrelas aleatórias
            self.mEstrelas =\
                EM.inteirosAleatorios(
                    1,
                    10,
                    2
                )
        # if-else

    # comportamentos
    # escrever
    # obter uma aposta [aleatória]
    # classificar/corrigir

    def __str__(self):
        # a representação direta da instância como frase
        r = ""

        bTemTitulo:bool = ""!=self.mTitulo.strip()
        if(bTemTitulo):
            r += f"Título: {self.mTitulo}\n"
        # if

        if(self.mFavorita):
            r+="Favorita: SIM\n"
        else:
            r+="Favorita: NÃO\n"

        # números
        r += "Números: "
        r += EM.colEnquantoFrase(
            self.mNumeros,
            pSeparador=", "
        )
        r +="\n"

        # estrelas
        r += "Estrelas: "
        r += EM.colEnquantoFrase(
            self.mEstrelas,
            pSeparador=", "
        )

        r+="\n"+("_"*60)
        return r
    # def __str__

    """
    Escreva o método dinâmico de nome
    quantosAcertosRelativamenteA
    que, recebida uma aposta EM,
    classifica a instância corrente relativamente
    à aposta recebida; isto é, contabiliza em quantos
    números e em quantos estrelas, as apostas
    coincidem.
    O retorno deverá ser um tuplo
    qDeNumerosAcertados, qEstrelasAcertadas
    """
    def quantosAcertosRelativamenteA(
        self,
        pOutra,
        pbVerEscritoOQueTemEmComum:bool=True
    ):
        setNumerosSelf = set(self.mNumeros)
        setEstrelasSelf = set(self.mEstrelas)
        setNumerosOutra = set(pOutra.mNumeros)
        setEstrelasOutra = set(pOutra.mEstrelas)
        numerosEmComum =\
            setNumerosSelf.intersection(setNumerosOutra)

        estrelasEmComum =\
            setEstrelasOutra.intersection(setEstrelasSelf)

        if(pbVerEscritoOQueTemEmComum):
            print(numerosEmComum)
            print(estrelasEmComum)

        return len(numerosEmComum), len(estrelasEmComum)
    # def quantosAcertosRelativamenteA

    def quantosAcertosRelativamenteA_v2(
        self,
        pOutra,
        pbVerEscritoOQueTemEmComum: bool = True
    ):
        iQNums, listQuaisNums =\
            EM.contadorDeCoincidenciasEntreColecoes(
                self.mNumeros,
                pOutra.mNumeros
            )

        iQEstrelas, listQuaisEstrelas = \
            EM.contadorDeCoincidenciasEntreColecoes(
                self.mEstrelas,
                pOutra.mEstrelas
            )

        if(pbVerEscritoOQueTemEmComum):
            #EM.colEnquantoFrase(listQuaisNums, " ")
            print(listQuaisNums)
            print(listQuaisEstrelas)
        # if

        return iQNums, iQEstrelas
    # def quantosAcertosRelativamenteA_v2

    @staticmethod
    def lerBDDeChaves\
        (pNomeDaBD:str="CHAVES.TSV"):

        ret = list()
        fr = open(pNomeDaBD, "rt")
        if(fr):
            conteudoTodo:str = fr.read()
            fr.close()

            colLinhas =\
                conteudoTodo.split("\n")

            for linha in colLinhas:
                linhaLimpa = linha.strip()
                if (linhaLimpa!=""):
                    colPartes =\
                        linhaLimpa.split("\t")

                    bFormatoCorreto = len(colPartes)==3
                    if(bFormatoCorreto):
                        data = colPartes[0]
                        nums = colPartes[1].split(" ")
                        est = colPartes[2].split(" ")

                        dict3Parts = dict()
                        # TODO: garantir listas de inteiros e NÃO listas de frases
                        dict3Parts["data"] = data
                        dict3Parts["nums"] = nums
                        dict3Parts["estrelas"] = est
                        ret.append(dict3Parts)
                    # if 3 partes
                # if linha limpa
            # for para todas as linhas
        # if conseguimos abrir ficheiros
        return ret
    # def lerBDDeChaves
# class EM

a1:EM = EM(
    pTitulo="O primeiro objeto EM q fizemos hoje",
    pNumeros = [1,2,3,4,5],
    pEstrelas = [1,2],
    pbFavorita = False,
) # será de números e estrelas aleatórios, porque NÃO argumentamos
a2:EM = EM(
    pTitulo="O segundo objeto EM q fizemos hoje",
    pNumeros=[2,3,4,5,6],
    pEstrelas=[2,3],
    pbFavorita=True
) # será de números e estrelas aleatórios, porque NÃO argumentamos

print(a1.__str__())
print(a2)
"""
print(a2.quantosAcertosRelativamenteA(a1)) # 4 acertos nums + 1 acerto estrelas

print("Usando v2:")
print(a2.quantosAcertosRelativamenteA_v2(a1)) # 4 acertos nums + 1 acerto estrelas
"""

chaveMaisRecentes = EM(
    [10,22,23,44,45],
    [8,9],
    "sorteio 2022-12-02"
)
print(chaveMaisRecentes)

"""
Sempre o que título não for vazio, quando se pede
a escrita de um objeto EM, deve aparecer o título.
"""

"""
sempre que for para mudar as características de TODAS
as instâncias (por exemplo, para ganharem + um atributo)
TEM QUE TRABALHAR-SE em __init__

sempre q for para mudar a representação/apresentação
enquanto frase de TODAS as instâncias (por exemplo,
para se escrever, ou não de uma maneira, ou de outra)
TEM QUE TRABALHAR-SE em __str__
"""

"""
Você decidiu q o formato para uma base de dados TSV
de chaves é:
<data do sorteio>\t<números>\t<estrelas>\n

Escreva um método, capaz de ler esta base de dados
e representa-la nalguma estrutura de dados.
"""

leitura = EM.lerBDDeChaves()
print(leitura)

"""
escrever uma função que, recebida uma coleção de
frases que representam inteiros
retorna a coleção equivalente, mas de inteiros.

"""

def solucao(pCol):
    ret = list()
    for el in pCol:
        iEl = int(el)
        ret.append(iEl)
    # for
    return ret
# def solucao