Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Solución reto deportistas

11/25
Recursos

Aportes 15

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Hola observando la solucion de Óscar y realizando lo mismo me di cuenta que esta haciendo la relación mal. Ya que la relación la esta haciendo con deportistaOlimpico.equipo_id = resultadoGanador.resultado_id.

Por ejemplo. Patimat Abakarova tiene un deportista_id = 65 y cuando busco ese id en el excel de resultados.csv y observo que si gano una medalla, pero la medalla no es de Oro, sino de Bronce.

Por lo que tuve que separar los join y crear dos RDDs. Aquí esta mi solución:

resultado_id medalla deportista_id juego_id evento_id
162 Bronze 65 51 81

Pero en la forma en que lo esta haciendo Óscar, esta buscando el 74, que es el equipo_id, en la columna de resultado_id, lo cual da lo siguiente:

resultado_id medalla deportista_id juego_id evento_id
74 Gold 20 44 32

Saludos.

El truco de este join es:

Dado el join que se acaba de realizar entre deportistaOlimpicoRDD y equiposOlimpicosRDD, hay que cambiar el valor llave (el cual es equipo_id) por deportista_id ya que éste valor es quien relaciona la tabla Deportista con la tabla Resultados.

Solo después de haber realizado el cambio de valor, ya se puede hacer el join. El cambio de llaves se hace simplemente ordenando la información con un map().

(deportistaOlimpicoRDD
           .map(lambda l : [l[-1],l[:-1]]) 
           .join(equiposOlimpicosRDD.map(lambda l : [l[0],l[2]]))
           .map(lambda l : (l[1][0][0], (l[0],l[1][0][1:],l[1][1]))) 
           .join(resultadoGanador.map(lambda l : [l[2],l[1]])) 
           .takeSample(False,6,25))

mi output es:

[('54832',
  (('982', ['Carlos Jimnez Snchez', '1', '24', '201', '100'], 'ESP'),
   'Silver')),
 ('135219',
  (('944', ['Urka olnir', '2', '22', '173', '64'], 'SLO'), 'Bronze')),
 ('106724',
  (('705', ['Adrie Ard Schenk', '1', '19', '190', '90'], 'NED'), 'Gold')),
 ('112317',
  (('1096', ['Justus Ketchum Smith', '1', '26', '0', '0'], 'USA'), 'Gold')),
 ('124518',
  (('705', ['Daniel Daan van Dijk', '1', '21', '0', '0'], 'NED'), 'Gold')),
 ('42668',
  (('1096', ['Joseph Tilford Lee Joe Greene', '1', '25', '183', '70'], 'USA'),
   'Bronze'))]

Mi solucion

deportistaOlimpicoRDD \
    .map(lambda deportista: [deportista[-1], deportista[:-1]]) \
    .join(equiposOlimpicosRDD.map(lambda equipo: [equipo[0], equipo[2]]))\
    .join(resultadoGanador.map(lambda resultado: [resultado[2], resultado[1]])) \
    .takeSample(False, 6, 25)

output

[('507',
  ((['18909', 'Enrico Castelli', '1', '27', '0', '0'], 'ITA'), 'Silver')),
 ('705',
  ((['99600', 'John Philip Ernest Marie Flip Regout', '1', '21', '0', '0'],
    'NED'),
   'Silver')),
 ('399',
  ((['15937', 'Magdalena Brzeska Peschel Sabolocka ', '2', '18', '173', '48'],
    'GER'),
   'Silver')),
 ('705',
  ((['13408',
     'Anna Johanna Geertruida Maria Annie Borckink',
     '2',
     '24',
     '0',
     '0'],
    'NED'),
   'Bronze')),
 ('705',
  ((['48310', 'Johannes Hendricus Heuckelbach', '1', '27', '0', '0'], 'NED'),
   'Gold')),
 ('619',
  ((['59062', 'Noraseela Mohd Khalid', '2', '32', '166', '55'], 'MAS'),
   'Gold'))]

Mi solución solucionando el problema de las relaciones con los ids es la siguiente es la siguiente:

# Join con el RDD de equipos, jugadores y resultados
allRDD = deportistaOlimpicoRDD.map(lambda l: (l[-1], (l[0],l[1]))).\
                join(equiposOlimpicosRDD.map(lambda x: (x[0], (x[-1]))))

DeportistasMedallasRDD = allRDD.map(lambda a: (a[1][0][0], a[0:])).\
                join(resultadoGanadorRDD.map(lambda r: (r[2], (r[1], r[3], r[4]))))

DeportistasMedallasRDD.map(lambda d: (d[1][0][1], d[1][1][0])).\
            takeSample(False, 5, 11)
[((('12941', 'Jeanette Bolden'), 'USA'), 'Gold'),
 ((('9803', 'Daima Mayelis Beltrn Guisado'), 'CUB'), 'Silver'),
 ((('77779', 'Jeffrey Dean Jeff McLaughlin'), 'USA'), 'Bronze'),
 ((('89894', 'Inna Volodymyrivna OsypenkoRadomska'), 'UKR'), 'Gold'),
 ((('74240', 'Aset Sekenovich Mambetov'), 'KAZ'), 'Bronze')]

Los datos arrojados por el ultimo join no son lo que buscamos dado que se está relacionando deportista_id con resultado_id y eso carece de lógica. Es facil de comprobar dado que Patimat Abakarova al día de hoy no ha ganado una medalla de oro, si no de bronce.
Se debe hacer un mareo para colocar como key deportista_id en el RDD resultadoGanador. De esta manera los resultados serán íntegros.

Me queda mucho la deuda de estar formando RDD en diferentes dimensiones, es decir listas como llaves y como datos, listas dentro de tuplas dentro de listas nuevamente, no entiendo aún eso.
La solución al reto:

deportistaPaises.map(lambda x: [x[1][0][0],[x[1][0][1:],x[1][1]]])\
    .join(resultadoGanador.map(lambda x: [x[2],x[0:2]+x[3:]])).top(2)
[('99996',
  ([['Sara Renner', '2', '21', '168', '63'], 'CAN'],
   ['199106', 'Silver', '46', '552'])),
 ('99992',
  ([['Karlheinz Heinz Renneberg', '1', '25', '182', '87'], 'GER'],
   ['199089', 'Gold', '23', '114']))]

inetresante

Tengo una duda, al momento de generar mi join no me da alguna información de salida? alguien sabe a que se debera?

Me imaginaba la solución como un one hot encoding, ya que un deportista puede tener mas de una medalla y la medalla tiene 3 categorias, hare el reto cuando aprendamos la parte de dataframes

Yo lo realizé de la siguiente forma

resultadosGanadorRDD.map(lambda l: (l[2],l[1])) \
                    .join(deportistaOlimpicoPais.map(lambda x: (x[1][0][0], x[1][0][1:] + [x[1][1]]))).take(6)

Hola!
Les comento un poco mi solución (es correcta solo habría que pulir un poco los matices). En la solución del profesor como habéis visto la relación está mal hecha.
Partiendo de que el objetivo es que se muestren los deportistas que hayan ganado alguna medalla y que salgan sus respectivos equipos el punto inicial debería ser resultados. Una vez haber hecho el join de resultados con deportistas solo habría que hacer otro join con los equipos (cambiando la clave).
Aquí el codigo:

Join deportista con resultado

deportistaGanador = resultadoGanador.map(lambda l : (l[2],l[1])).join(deportistaOlimpico.map(lambda l : (l[0] , l[0:] )))

Join deportistaGanador con equipo (cambiando la clave)

resultadoFinalRDD = deportistaGanador.map(lambda l : ( l[1][1][-1] , l[1] )).join(equiposOlimpicosRDD.map(lambda l : ( l[0], l[2] )))

Aqui el matiz es que dentro de la tupla se repite dos veces el id de equipo. Solo de manera visual, la solucion a mi parecer es correcta.
Espero que os sirva de ayuda.

Saludos a todos. Les comparto mi solución:

deportista_olimpicos_RDD.map(lambda i: [i[-1], i[:-1]]) \
            .join(equipos_olimpicos_RDD.map(lambda j: [j[0], j[-1]])) \
            .join(resultado_ganador_RDD.map(lambda k: [k[2], k[1]])) \
            .take(1) 

Un buen ejercicio para comprobar que la respuesta es correcta fue comparar con filtros en Excel.

Solución Spark:

Excel:

Mi solución, devuelve una tabla más organizada.

deportistaPaisesRDD = ((deportistaOlimpicoRDD \
    .map(lambda deportista: itemgetter(-1,slice(0,-1))(deportista)) \
    .join(equiposOlimpicosRDD\
        .map(lambda equipo:  itemgetter(0,2)(equipo))))\
    .map(lambda deportista: [
        deportista[1][0][0],
        [*deportista[1][0][1:6], deportista[0],deportista[1][1]]
    ])\
    .join(resultadoGanador.map(lambda resultado: [resultado[2], resultado[1]])))\
    .map(lambda deportista: (deportista[0],*deportista[1][0],deportista[1][1]))
    
deportistaPaisesRDD.take(6)

se puede verificar que el JOIN del profesor esta errado, en el RDD de resultados coloque el deportista_id de cualquier resultado del profesor y se dan cuenta que la medalla no coincide

deportistaPaises = deportistaOlimpicoRDD.map(lambda l: [l[-1], l[:-1]]) \
    .join(equiposOlimpicosRDD.map(lambda x: [x[0], x[2]])) \
    .join(resultadoGanador.map(lambda r: [r[2], r[1]]))
    
deportistaPaises.takeSample(False,6,25)#sin valores repetidos, valores a visualizar, semilla aleatoria