Laboratorio 02- 04

[MariaAlfs]

Buenas tardes profe,
Espero que se encuentre bien.
Con respecto al task 1 de las cartas me encuentro en una encrucijada con respecto al código que planteé, debido a que cumple con la regla de que el primer elemento del deck está en el primer heap y el segundo el primero del segundo heap... hasta ahí todo bien, pero el problema es que las cartas en heap se me repiten y no salen de 2 en 2 como se requeriría.

Mi código es este:
def make_heaps(c, n_heaps=3):
   assert n_heaps % 2 == 1, "must have an odd number of heaps"
   assert len(c) % n_heaps == 0, "the length of the deck must be a multiple of the number of heaps"
   cards_per_heap = len(c) // n_heaps
   cards_per_heap = len(c) // n_heaps
   h = [c[i:i+cards_per_heap] for i in range(0,len(c),1)]
   return h

He intentado de todo pero me quedé sin ideas...
Profe, requiero de su ayuda.
Gracias

edited by felipe: added code blocks

[franco-arroyave]

Hola, hice dos pruebas usando ciclos te comento los resultado

1. El resultado es la matriz esperada pero transpuesta, esto es lo mas próximo a lo que tenias.

def make_heaps(c, n_heaps=3):
  assert n_heaps % 2 == 1, "must have an odd number of heaps"
  assert len(c) % n_heaps == 0, "the length of the deck must be a multiple of the number of heaps"
  cards_per_heap = len(c) // n_heaps

  h = [[c[(i*j)-1] for j in range(1,n_heaps+1)] for i in range(1,cards_per_heap+1)] # da como resultado la matriz transpuesta
  return h

2. Usando for y creando previamente la matriz h se logro el resultado esperado.

def make_heaps(c, n_heaps=3):
  assert n_heaps % 2 == 1, "must have an odd number of heaps"
  assert len(c) % n_heaps == 0, "the length of the deck must be a multiple of the number of heaps"
  cards_per_heap = len(c) // n_heaps

  h = [] # Crea un array vacío
  for i in range(0,n_heaps): # Llenar h con el numero de Heaps
    h.append([])
 
  for i in range(1,cards_per_heap+1):
    for j in range(1,n_heaps+1):
      h[j-1].append(c[(i*j)-1]) # Se desplazan los range + 1 y luego se resta para evitar que el producto por cero dañe los índices en c
      
  return h

Recomendación: Usa numpy, con reshape y la transpuesta sale en una línea de código.

EDITED BY FELIPE: ADDED CODE BLOCKS

[Felipe-RA]

Saludos @MariaAlfs @franco-arroyave

Muchas gracias por vuestros aportes.

¡Recuerden usar la funcionalidad de bloques de código que está en la barra de herramientas de estas cajas de texto para facilitar revisar vuestro código!

Con respecto al código:

@MariaAlfs

El problema que tienes se origina de una implementación erronea de la list comprehension y del slicing

Recuerda que el slicing funciona con la estructura [start:stop:step] , en donde step es el número de "saltos" que realizas sobre la lista hasta tomar un elemento de ella nuevamente.

En nuestro caso, queremos que cada heap tenga el número de cartas n_heaps, puesto que la definición del problema indica:

The heaps must be a list of n_heaps lists, each one with len(c)/n_heaps card names.

Entonces, para lograr esto organizamos el siguiente slicing con list comprehension:

[c[i::n_heaps] for i in range(n_heaps)]

Es bastante parecido al tuyo, pero tiene las siguientes diferencias:

1. En este [start:stop:step], nuestro start será el número del heap en el que estamos recorriendo.
2. Nuestro stop no esta definido (por eso están vacios el espacio entre los dos puntos : :, esto significa que recorre la baraja (el iterable c) hasta el final.
3. Nuestro step es el número de heaps n_heaps. Esto nos garantiza que le estamos dejando las cartas que necesita el siguiente montón.
4. Por último, el rango está definido como n_heaps, pues necesitamos obtener ese número de montones.

La interpretación intuitiva de esta implementación puede quedarte más clara con este ejemplo:

Están jugando el J1, J2, J3, necesitaremos 3 montones pues hay 3 jugadores n_heaps = 3

El maestro de la mesa toma la baraja c, esta tiene 30 cartas.

Con esto sabemos que el número de cartas por heaps será len(c)/n_heaps, esto sería 30/3 = 10

Después de barajarla comienza a crear los montones para cada jugador, normalmente le pasaría una carta a J1, luego otra a J2 y finalmente otra a J3.

Sin embargo, esta implementación basada sólo en slicing no hace esto, lo que hace es darle la primera carta c[0] a J1, (este sería el primer heap i = 0 ), hace un salto de 3 y le da la carta c[3] a J1, luego hace un salto de 3 y le da la carta c[6].

Este proceso se repite hasta el final de la baraja, en donde llegamos al elemento c[27] (recordemos que c[30] está por fuera del rango del vector, puesto que empieza desde 0, el vector de 30 elementos llega hasta el índice 29).

Ahora, se empiezan a repartir las cartas del jugador J2, con el segundo heap (i = 1). Como se empieza con i = 1 la primera carta es c[1], la segunda carta es c[4], y así hasta que la última carta del J2 es c[28]

Finalmente, las cartas del tercer jugador J3, tendra i=2, empezará desde la tercera carta c[2], su segunda carta será c[5] y su última carta será la última de la baraja c[29]

Fijate que nunca se sobreponen las cartas de un jugador sobre las de otro con estos índices

Este ejemplo es una muestra del potencial del slicing y del list comprehension para resolver problemas con pocas instrucciones de código.

Por supuesto, las soluciones ofrecidas por @franco-arroyave son también válidas, una muestra más de todas las bellas formas que hay de acercarse a los problemas con distintas nociones matemáticas y lógicas ❤️