No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Solución reto deportistas

11/25
Recursos

Aportes 21

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 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.

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'))]

La verdad que me parece bastante mal que haya clases como estas, sin estar chequeadas al %100 en una plataforma seria como esta y que todavia no hayan cambiado el video con la correcion adecuada.

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)

Comparto mi solución

resultadosGanador.map(lambda l: [l[2], l[1]]).join(deportistaEquipo.map(lambda x: [x[0], (x[1][0][1], x[1][1])])).takeSample(False, 5, 20)```

Mi solución a este reto fue la siguiente:

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

Mi solución organizando los valores finalmente para que sea posible guardarlos en un CSV sin necesidad de utilizar llave valor.

olimpicAthletesTeams = olimpicAthletesRDD \
    .map(lambda l: [l[-1], l[:]]) \
    .join(olimpicTeams.map(lambda n: [n[0], n[2]]))

# Ordering the process to use the athlete id as key
olimpicAthletesTeams = olimpicAthletesTeams.map(lambda l: [l[1][0][0], l[1][0][0:-1]+[l[1][1]]])

# Joining athletes and results
resultsAthletes = results.map(lambda l: [l[2], l[1]]) \
    .join(olimpicAthletesTeams)

# Ordering values to delete keys and save the result as csv
resultsAthletes = resultsAthletes.map(lambda l: l[1][1]+[l[1][0]])

olimpicAthletesTeams.takeSample(False, 6, 25)
deportistaOlimpicoRDD.map(lambda l: [l[-1], l[:-1]]) \
      .join(equiposolimpicosRDD.map(lambda x: [x[0], x[2]])) \
      .join(resultadoGanador.map(lambda z: [z[2], z[1::2]])) \
      .take(3) 

Esta es mi solución necesité hace un map a la relación deportistaOlimpicoRDD y equipoOlimpicoRDD para acceder al Id del deportista por ello utilice el u[1][0][0] una ves obtenida solo incorporé el nuevo join para que exista la relación.

(deportistaOlimpicoRDD.map(lambda l: [l[-1], l[:-1]]) \
.join(equipoOlimpicosRDD.map(lambda x : [x[0],x[2]]))) \
.map(lambda u: [u[1][0][0],u[:]]) \
.join(resultadoGanador.map(lambda r : [r[2],r[:]])) \
.takeSample(False, 6, 25)

Resultado

[('54832',
  (('982',
    (['54832', 'Carlos Jimnez Snchez', '1', '24', '201', '100'], 'ESP')),
   ['108459', 'Silver', '54832', '47', '1'])),
 ('135219',
  (('944', (['135219', 'Urka olnir', '2', '22', '173', '64'], 'SLO')),
   ['270305', 'Bronze', '135219', '45', '223'])),
 ('106724',
  (('705', (['106724', 'Adrie Ard Schenk', '1', '19', '190', '90'], 'NED')),
   ['212561', 'Gold', '106724', '28', '59'])),
 ('112317',
  (('1096', (['112317', 'Justus Ketchum Smith', '1', '26', '0', '0'], 'USA')),
   ['223625', 'Gold', '112317', '17', '98'])),
 ('124518',
  (('705', (['124518', 'Daniel Daan van Dijk', '1', '21', '0', '0'], 'NED')),
   ['248729', 'Gold', '124518', '11', '379'])),
 ('42668',
  (('1096',
    (['42668', 'Joseph Tilford Lee Joe Greene', '1', '25', '183', '70'],
     'USA')),
   ['83952', 'Bronze', '42668', '41', '68']))]

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