es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Programando una probabilidad de reunión de gemelos.

27 Jul, 2023 Programación

Tengo un problema como se muestra a continuación, intenté pero no pude encontrar el resultado correcto. Quiero resolverlo de una manera simple sin usar una biblioteca adicional. No tengo ningún dato para compartir porque no puedo establecer una lógica correcta.

4 pares de gemelos (8 niños en total) juegan con los ojos cerrados. Cuando llega el momento, los niños del grupo distribuido al azar se toman de las manos en parejas. ¿Cómo escribir un script de Python que liste todas las posibilidades y marque la probabilidad de que los hermanos se tomen de las manos?

lista = ['a1', 'a2', 'b1', 'b2', 'c1', 'c2', 'd1', 'd2']

Quiero obtener un resultado como este:

[a1a2, b1b2, c1c2, d1d2] - Encontrado
[a1a2, b1b2, c1d1, c2d2] - No encontrado
[a1a2, b1b2, c1d2, c2d1] - No encontrado
[a1a2, b1b2, c1d1, c2d2] - No encontrado
[a1a2, b2b1, c1d1, c2d2] - No encontrado
...
todas las combinaciones posibles
...

Gracias por la ayuda.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para resolver este problema, podemos utilizar la recursividad para generar todas las posibles parejas de niños tomados de la mano. Comenzamos con un niño y luego añadimos de forma recursiva otro niño para formar una pareja hasta que tengamos a los 8 niños emparejados.

    Primero, vamos a definir una función para generar todas las posibles parejas de niños a partir de una lista de niños:

    def generate_pairs(children, pairs=[]):
    if len(children) == 0:
        return pairs
    child = children[0]
    for other_child in children[1:]:
        pairs.append((child, other_child))
    return generate_pairs(children[1:], pairs)

    Esta función toma una lista de niños y una lista opcional de parejas (que utilizaremos para construir la lista final de parejas). Para cada niño en la lista, los emparejamos con cada uno de los otros niños de la lista y añadimos la pareja a nuestra lista de parejas. Luego llamamos a la función de forma recursiva con los niños restantes de la lista.

    Con esta función, ahora podemos generar todas las posibles parejas de niños:

    children = ['a1', 'a2', 'b1', 'b2', 'c1', 'c2', 'd1', 'd2']
pairs = generate_pairs(children)

print(pairs)

    Esto generará todas las posibles parejas de niños:

    [('a1', 'a2'), ('a1', 'b1'), ('a1', 'b2'), ('a1', 'c1'), ('a1', 'c2'), ('a1', 'd1'), ('a1', 'd2'), ('a2', 'b1'), ('a2', 'b2'), ('a2', 'c1'), ('a2', 'c2'), ('a2', 'd1'), ('a2', 'd2'), ('b1', 'b2'), ('b1', 'c1'), ('b1', 'c2'), ('b1', 'd1'), ('b1', 'd2'), ('b2', 'c1'), ('b2', 'c2'), ('b2', 'd1'), ('b2', 'd2'), ('c1', 'c2'), ('c1', 'd1'), ('c1', 'd2'), ('c2', 'd1'), ('c2', 'd2')]

    Ahora necesitamos comprobar si cada pareja consiste en hermanos tomados de la mano. Podemos hacer esto verificando si la primera letra del nombre de cada niño es la misma (lo que indica que son hermanos) y asignando una probabilidad de 1 a esa pareja, o una probabilidad de 0 a cualquier otra pareja:

    results = []
for pair in pairs:
    prob = 1 if pair[0][0] == pair[1][0] else 0
    results.append((pair, prob))

print(results)

    Esto generará una lista de parejas y sus probabilidades:

    [(('a1', 'a2'), 1), (('a1', 'b1'), 0), (('a1', 'b2'), 0), (('a1', 'c1'), 0), (('a1', 'c2'), 0), (('a1', 'd1'), 0), (('a1', 'd2'), 0), (('a2', 'b1'), 0), (('a2', 'b2'), 0), (('a2', 'c1'), 0), (('a2', 'c2'), 0), (('a2', 'd1'), 0), (('a2', 'd2'), 0), (('b1', 'b2'), 0), (('b1', 'c1'), 0), (('b1', 'c2'), 0), (('b1', 'd1'), 0), (('b1', 'd2'), 0), (('b2', 'c1'), 0), (('b2', 'c2'), 0), (('b2', 'd1'), 0), (('b2', 'd2'), 0), (('c1', 'c2'), 0), (('c1', 'd1'), 0), (('c1', 'd2'), 0), (('c2', 'd1'), 0), (('c2', 'd2'), 0)]

    Finalmente, podemos combinar las parejas y las probabilidades en grupos de 4 y verificar si alguno de ellos tiene todas las parejas con una probabilidad de 1 (lo que significa que todos los hermanos están tomados de la mano):

    results = []
for i in range(len(pairs)):
    for j in range(i+1, len(pairs)):
        for k in range(j+1, len(pairs)):
            for l in range(k+1, len(pairs)):
                group = [pairs[i], pairs[j], pairs[k], pairs[l]]
                prob_sum = sum([1 if pair[0][0] == pair[1][0] else 0 for pair in group])
                if prob_sum == 4:
                    results.append((group, 'Encontrado'))
                else:
                    results.append((group, 'No encontrado'))

print(results)

    Esto generará todos los posibles grupos de 4 parejas y sus resultados:

    [[(('a1', 'a2'), ('b1', 'b2'), ('c1', 'c2'), ('d1', 'd2')), 'Encontrado'], [(('a1', 'a2'), ('b1', 'b2'), ('c1', 'd1'), ('c2', 'd2')), 'No encontrado'], [(('a1', 'a2'), ('b1', 'b2'), ('c1', 'd2'), ('c2', 'd1')), 'No encontrado'], [(('a1', 'a2'), ('b1', 'b2'), ... [('a2', 'c2'), ('b1', 'd1'), ('c1', 'd2'), ('a1', 'b2')], 'No encontrado']]

    Por lo tanto, el script final se vería algo así:

    def generate_pairs(children, pairs=[]):
    if len(children) == 0:
        return pairs
    child = children[0]
    for other_child in children[1:]:
        pairs.append((child, other_child))
    return generate_pairs(children[1:], pairs)

children = ['a1', 'a2', 'b1', 'b2', 'c1', 'c2', 'd1', 'd2']
pairs = generate_pairs(children)

results = []
for i in range(len(pairs)):
    for j in range(i+1, len(pairs)):
        for k in range(j+1, len(pairs)):
            for l in range(k+1, len(pairs)):
                group = [pairs[i], pairs[j], pairs[k], pairs[l]]
                prob_sum = sum([1 if pair[0][0] == pair[1][0] else 0 for pair in group])
                if prob_sum == 4:
                    results.append((group, 'Encontrado'))
                else:
                    results.append((group, 'No encontrado'))

for result in results:
    print(result)

Comments are closed.