Ir para conteúdo
Fórum Script Brasil
  • 0

Função random.shuffle não gera uma lista pré-definida.


glauberec

Pergunta

Boa noite,

Gostaria de gerar listas onde cada item das listas entre si não sejam iguais.

Por exemplo, 

Dadas as listas L01 = ['A', 'B', 'C', 'C'] e L02 = ['D', 'B', 'C', 'C'], o script me gere listas do tipo L01_2 = ['A', 'C', 'C', 'B'] e L02_2 =  ['C', 'B', 'D', 'C'], que são permutações de L01 e L02, onde L01_2[0] seja diferente de L02_2[0], L01_2[1] seja diferente de L02_2[1], L01_2[2] seja diferente de L02_2[2] e L01_2[3] seja diferente de L02_2[3].

Abaixo está o script:

from random import shuffle

dimp = 0
contagem = 0

nonA = ['Q', 'A', 'B',
        'A', 'T', 'C',
        'D', 'A',
        'D',
        'T']

priA = ['T', 'L', 'C',
        'B', 'C', 'C',
        'X', 'F',
        'H',
        'G',
        'J',
        'F', 'T']

priB = ['D', 'L', 'G',
        'H', 'F', 'T',
        'B', 'F',
        'D',
        'T',
        'K', 'J',
        'D', 'G', 'J']

segA = ['J', 'C', 'C',
        'F', 'Q', 'P',
        'H', 'P',
        'E',
        'F',
        'J',
        'P', 'Q']

segB = ['F', 'R', 'M',
        'J', 'P', 'P',
        'E', 'L',
        'F',
        'H',
        'C',
        'C', 'C']

terA = ['H', 'L', 'L',
        'P', 'R', 'C',
        'M', 'P',
        'X',
        'E',
        'F',
        'F', 'M']

terB = ['G', 'Z', 'G',
        'E', 'P', 'H',
        'F', 'L',
        'K',
        'G',
        'L',
        'F', 'C']

while True:
    dimp = 0
    shuffle(nonA)
    shuffle(priA)
    shuffle(priB)
    shuffle(segA)
    shuffle(segB)
    shuffle(terA)
    shuffle(terB)

    aula0 = [nonA[0], priA[0], priB[0], segA[0], segB[0], terA[0], terB[0]]
    aula1 = [nonA[1], priA[1], priB[1], segA[1], segB[1], terA[1], terB[1]]
    aula2 = [nonA[2], priA[2], priB[2], segA[2], segB[2], terA[2], terB[2]]
    aula3 = [nonA[3], priA[3], priB[3], segA[3], segB[3], terA[3], terB[3]]
    aula4 = [nonA[4], priA[4], priB[4], segA[4], segB[4], terA[4], terB[4]]
    aula5 = [nonA[5], priA[5], priB[5], segA[5], segB[5], terA[5], terB[5]]
    aula6 = [nonA[6], priA[6], priB[6], segA[6], segB[6], terA[6], terB[6]]
    aula7 = [nonA[7], priA[7], priB[7], segA[7], segB[7], terA[7], terB[7]]
    aula8 = [nonA[8], priA[8], priB[8], segA[8], segB[8], terA[8], terB[8]]
    aula9 = [nonA[9], priA[9], priB[9], segA[9], segB[9], terA[9], terB[9]]
    aula10 = [priA[10], priB[10], segA[10], segB[10], terA[10], terB[10]]
    aula11 = [priA[11], priB[11], segA[11], segB[11], terA[11], terB[11]]
    aula12 = [priA[12], priB[12], segA[12], segB[12], terA[12], terB[12]]

    cont = 0
    for c in aula0:
        for d in aula0:
            if d != c:
                cont += 1
    if cont == len(aula0) * (len(aula0) - 1):
        dimp += 1
        cont = 0
        for c in aula1:
            for d in aula1:
                if d != c:
                    cont += 1
        if cont == len(aula1) * (len(aula1) - 1):
            dimp += 1
            cont = 0
            for c in aula2:
                for d in aula2:
                    if d != c:
                        cont += 1
            if cont == len(aula2) * (len(aula2) - 1):
                dimp += 1
                cont = 0
                for c in aula3:
                    for d in aula3:
                        if d != c:
                            cont += 1
                if cont == len(aula3) * (len(aula3) - 1):
                    dimp += 1
                    cont = 0
                    for c in aula4:
                        for d in aula4:
                            if d != c:
                                cont += 1
                    if cont == len(aula4) * (len(aula4) - 1):
                        dimp += 1
                        cont = 0
                        for c in aula5:
                            for d in aula5:
                                if d != c:
                                    cont += 1
                        if cont == len(aula5) * (len(aula5) - 1):
                            dimp += 1
                            cont = 0
                            for c in aula6:
                                for d in aula6:
                                    if d != c:
                                        cont += 1
                            if cont == len(aula6) * (len(aula6) - 1):
                                dimp += 1
                                cont = 0
                                for c in aula7:
                                    for d in aula7:
                                        if d != c:
                                            cont += 1
                                if cont == len(aula7) * (len(aula7) - 1):
                                    dimp += 1
                                    cont = 0
                                    for c in aula8:
                                        for d in aula8:
                                            if d != c:
                                                cont += 1
                                    if cont == len(aula8) * (len(aula8) - 1):
                                        dimp += 1
                                        cont = 0
                                        for c in aula9:
                                            for d in aula9:
                                                if d != c:
                                                    cont += 1
                                        if cont == len(aula9) * (len(aula9) - 1):
                                            dimp += 1
                                            cont = 0
                                            for c in aula10:
                                                for d in aula10:
                                                    if d != c:
                                                        cont += 1
                                            if cont == len(aula10) * (len(aula10) - 1):
                                                dimp += 1
                                                cont = 0
                                                for c in aula11:
                                                    for d in aula11:
                                                        if d != c:
                                                            cont += 1
                                                if cont == len(aula11) * (len(aula11) - 1):
                                                    dimp += 1
                                                    cont = 0
                                                    for c in aula12:
                                                        for d in aula12:
                                                            if d != c:
                                                                cont += 1
                                                    if cont == len(aula12) * (len(aula12) - 1):
                                                        dimp += 1
    contagem += 1
    print(contagem)
    if dimp == 13:
        break
print(nonA)
print(priA)
print(priB)
print(segA)
print(segB)
print(terA)
print(terB)

O que ocorre com esse código é que ele parece estar rodando o while, mas nunca chega a uma permutação da forma desejada.

 

Desde já, muito grato!
 

Link para o comentário
Compartilhar em outros sites

4 respostass a esta questão

Posts Recomendados

  • 0

você não pode usar permutações no modulo itertools?

from itertools import permutations, chain

a = 'ABCC'
b = 'DBCC'

a_per = permutations(a)
b_per = permutations(b)

a_b = chain(a_per, b_per)

s = set(a_b)
s = sorted(s)

print(*s, sep='\n')

 

Link para o comentário
Compartilhar em outros sites

  • 0
Em 28/03/2019 em 19:57, ArteEN disse:

você não pode usar permutações no modulo itertools?


from itertools import permutations, chain

a = 'ABCC'
b = 'DBCC'

a_per = permutations(a)
b_per = permutations(b)

a_b = chain(a_per, b_per)

s = set(a_b)
s = sorted(s)

print(*s, sep='\n')

Muitíssimo obrigado.

Nesse caso me é gerado as permutações de a e de b. Teria como o script apresentasse pelo menos uma permutação da lista a e outra permutação da lista b de maneira que o n-ésimo elemento da lista "a" seja diferente do n-ésimo elemento da lista "b"? como por exemplo ['A', 'B', 'C', 'C']  e ['C', 'D', 'A', 'B']?   

 

Link para o comentário
Compartilhar em outros sites

  • 0
from itertools import permutations

def nDiferente(a, b):
    for x, y in zip(a, b):
        if x == y:
            return 0
    return 1

def compararAB(lista_1, lista_2):
    for a in lista_1:
        for b in lista_2:
            if nDiferente(a, b):
                return(a, b)

    return (0, 0)
            


a = 'ABCC'
b = 'DBCC'

a_per = set(permutations(a))
b_per = set(permutations(b))

exclusivos = compararAB(a_per, b_per)

print(exclusivos)

é o melhor que consigo pensar no momento

Link para o comentário
Compartilhar em outros sites

Participe da discussão

Você pode postar agora e se registrar depois. Se você já tem uma conta, acesse agora para postar com sua conta.

Visitante
Responder esta pergunta...

×   Você colou conteúdo com formatação.   Remover formatação

  Apenas 75 emoticons são permitidos.

×   Seu link foi incorporado automaticamente.   Exibir como um link em vez disso

×   Seu conteúdo anterior foi restaurado.   Limpar Editor

×   Você não pode colar imagens diretamente. Carregar ou inserir imagens do URL.



  • Estatísticas dos Fóruns

    • Tópicos
      152k
    • Posts
      651,7k
×
×
  • Criar Novo...