Jump to content
Fórum Script Brasil
  • 0

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


Question

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 to post
Share on other sites

4 answers to this question

Recommended Posts

  • 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 to post
Share on other 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 to post
Share on other 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 to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



  • Forum Statistics

    • Total Topics
      148688
    • Total Posts
      644522
×
×
  • Create New...