FP 2022-11-22

# bs.py - Bubble Sort
import time
"""
Algoritmo para ordenar ascendentemente (do menor para o maior) coleções
exemplo: coleções de inteiros
critério: posicionamento dos inteiros na reta real
trabalha-se até a coleção estar ordenar
enquanto a COL NÃO está ordenada há q tentar ordená-la:
fazer passeios do primeiro ao PEnúltimo elemento da coleção
o que se faz em cada passeio é
comparar cada elemento com o seu vizinho/adjacente/seguinte
se encontramos os elementos atual e seguinte
FORA da ordem desejada há que:
1) trocá-los (algoritmo da troca)
2) tomar nota q foi feita uma troca

quando um passeio termina
temos que perguntar-nos
FIZ TROCAS?
Se a resposta for não, podemos considerar
a coleção ordenada e terminar.

bOrdenada = False
bTrocas = False
4 3 2 1
4>3 True => troquei e FIZ TROCA
3 4 2 1
4>2 True => troquei e FIZ TROCA
3 2 4 1
4>1 True => troquei e FIZ TROCA

Passeio #2
bTrocas = False
3 2 1 4
3>2 True => troquei e FIZ TROCA
2 3 1 4
3>1 True => troquei e FIZ TROCA
2 1 3 4
3>4 False => FAÇO NADA
2 1 3 4
houve trocas (SIM)
posso assumir q ficou ordenada NÃO
exige-se +1 passeio

2 1 3 4
2>1 True ? Troco Aponto q faço troca
1 2 3 4
2>3 False? FAÇO NADA
1 2 3 4
3>4 False? FAÇO NADA
1 2 3 4

bTrocas = False
1 2 3 4

bOrdenada = True
"""

# numa lista com n elementos
# os passeios serão
# de 0 (zero) ao index n-1-1
def bsAsc(pCol:list):
    numDePasseios = 0
    numDeTrocas = 0
    bOrdenada = False
    passeioDoPrimeiroAoPenultimo = range(
        0, # do primeiro
        len(pCol) - 1 # ao penúltimo (notar q este valor será excluido)
    )
    while not bOrdenada:
        numDePasseios+=1
        bFizTrocas = False
        for endereco in passeioDoPrimeiroAoPenultimo:
            el = pCol[endereco]
            vizinho = pCol[endereco+1]
            bHaMotivosParaTrocar = el>vizinho

            strMsg = f"Passeio #{numDePasseios} ; Coleção atualmente: {pCol}\n"
            strMsg+= f"Vou comparar endereço {endereco} que vale {pCol[endereco]}"
            strMsg+=f" com endereço {endereco+1} que vale {pCol[endereco+1]}\n"
            strMsg+=f"Há motivos para trocar? {bHaMotivosParaTrocar}"
            print(strMsg)

            if(bHaMotivosParaTrocar):
                numDeTrocas+=1
                # algoritmo da troca
                temp = pCol[endereco]
                pCol[endereco] = pCol[endereco+1]
                pCol[endereco+1] = temp
                bFizTrocas = True

                strMsg=f"Houve uma troca, a coleção ficou assim:\n{pCol}"
                print(strMsg)
            # if
        # for passeio do 1º ao penúltimo elemento da pCol
        #time.sleep(15)

        strMsg="*"*40
        print(strMsg)

        # no final do passeio
        if not bFizTrocas:
            bOrdenada = True
        #if
# def

col = [4,3,2,1]
print (f"Antes: {col}")
bsAsc(col)
print (f"Depois: {col}")

col = ["Artur", "Zélia", "Rita", "Ana", "Lurdes", "John"]
print (f"Antes: {col}")
bsAsc(col)
print (f"Depois: {col}")

"""
Q1: O que retorna a função bs?
None
Q2 : Modifique bs para que retorne a col ordenada
return pCol
Q3 : Modifique bs para que retorne o número de passeios *e* o número de trocas
return numDePasseios, numDeTrocas
Q4 : Qual é o tipo de retorno
Tuple
type(bsAsc([]))
"""
col = [4,44,12]
resposta = bsAsc(col)
print(resposta)


*********
# ex3.py

def umaFuncao(pUmParam):
    pUmParam = pUmParam+10
# def

"""
Em Python temos "passagem por valor"
Significa que o param "associa-se" com uma cópía do valor do argumento
mas não com o original
portanto, não altera o argumento
não há efeitos colaterais
"""

umArgumento = 2
resultado = umaFuncao(umArgumento)
print(f"umArgumento={umArgumento} ; resultado={resultado}")