Entrada

Tome una lista de valores x _i cada uno emparejado con una clave y _i .

[(x1, y1), (x2, y2), ...]

Salida

Devuelve una lista L que contiene solo valores del conjunto { x _i }.

• La longitud de L debe ser igual al número de claves únicas k en el conjunto { y _i }.
• Para cada clave única k debe haber un valor de { x _i } que tenga la clave k .

Detalles

• Lagunas estándar no permitidas.
• Puede suponer que todos los valores en la entrada serán enteros no negativos.
• Puede haber valores y claves duplicados.
• Puede suponer que hay al menos un par valor / clave en la entrada.
• Si prefiere tomar dos listas de igual longitud como entrada (una para valores, otra para claves), está bien.
• No puede tomar ninguna otra entrada.
• El orden de la lista que genera no importa.
• La x _i que elija para cada tecla no importa.

Por ejemplo, la entrada [[0, 0], [1, 3], [2, 3]]se puede devolver cualquiera [0, 1]o [0, 2]o cualquier permutación de estos.

Ejemplos

[[1, 2], [3, 2], [3, 0]]  -> [1, 3] or [3, 3]
[[7, 2], [7, 0], [7, 1]]  -> [7, 7, 7]
[[4, 0], [4, 0], [9, 1], [5, 2]]  -> [4, 9, 5]
[[9, 1], [99, 10], [5, 5], [0, 3]]  -> [9, 99, 5, 0]

Pocos bytes ganan.

Python 2 , 34 bytes

lambda a,b:dict(zip(b,a)).values()

Pruébalo en línea!

Toma entrada como lista de valores y lista de claves.
Genere diccionario, intercambiando claves y valores, que deja solo valores y únicos. Devuelve todos los valores de x correspondientes

Jalea , 2 bytes

Ḣƙ

Pruébalo en línea!

Toma dos listas de igual longitud, primero son las claves, segundo son los valores.

J , 4 bytes

{./.

¿Cómo?

El argumento de la izquierda xes una lista de claves, la correcta y, una lista de valores

/.grupos de yacuerdox

{. toma el primer elemento de cada grupo

Pruébalo en línea!

Clojure, 20 18 bytes

(comp vals zipmap)

Esto toma listas de valores y claves como argumentos, en ese orden.

Python 3 , 42 bytes

lambda a,b:[dict(zip(b,a))[q]for q in{*b}]

Pruébalo en línea!

a = valores
b = teclas

Haskell , 49 47 bytes

map fst.nubBy((.snd).(==).snd)
import Data.List

Pruébalo en línea! Entrada como una lista de tuplas, por ejemplo [(1, 2), (3, 2), (3, 0)].

Entrada como lista de listas (49 bytes)

map(!!0).nubBy(\a b->a!!1==b!!1)
import Data.List

Pruébalo en línea!

JavaScript (ES8), 43 bytes

Toma la entrada como 2 listas distintas en la sintaxis de curry (values)(keys).

v=>k=>v.filter(o=(x,i)=>o[j=k[i]]?0:o[j]=1)

Pruébalo en línea!

Casco , 4 bytes

ṁhüt

Pruébalo en línea!

¿Cómo?

--hüt - Programa completo. 
  üt - Agrupar por cola (las listas sin el primer elemento).
ṁh - Cabezas de mapa (las listas sin el último elemento) y concatenar los resultados.

Stax , 5 bytes

╠HB%§

Ejecutar y depurarlo

Toma dos matrices, primero valores, luego claves.

Explicación:

cu:I@J Full program, unpacked
cu     Push a unique copy of the keys.
  :I   Indices of the unique elements
    @  Index the values array
     J Join by space
       Implicit output

R , 30 bytes

function(x,y)x[!duplicated(y)]

Pruébalo en línea!

Japt , 8 bytes

â £VgUbX

Intérprete Japt

Gracias a Shaggy por guardar 1 último byte

Completamente reelaborado la lógica. Toma algunas pistas de la respuesta de Luis, pero creo que todavía ha mejorado. Ahora toma la entrada como dos listas, keys, values. Aparentemente todavía estoy por debajo de lo óptimo.

Explicación:

â £         For each unique Key X
     Ub     find the first index in "keys"
       X    which is equal to X
   Vg       then take the "value" with the same index

Rubí , 27 bytes

->a,b{b.zip(a).to_h.values}

Pruébalo en línea!

Toma datos como dos matrices (el pie de página transforma los casos de prueba originales en este formato).

05AB1E , 4 bytes

DÙkè

Tome dos listas de entrada: primero los valores, luego las claves.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

D        # Duplicate the values-list
 Ù       # Get all unique items of the values-list
         #  i.e. [0,0,1,0,2] → ['0','1','2']
  k      # Get all (first) indices of these unique values
         #  i.e. [0,0,1,0,2] and ['0','1','2'] → [0,2,4]
   è     # And use this index to get the key from the keys-list
         #  i.e. [0,2,4] and [4,4,9,5,4] → [4,9,4]

Java 8, 82 bytes

Una lambda de una corriente de int[]pares a java.util.Collection<Integer>.

m->m.collect(java.util.stream.Collectors.toMap(a->a[1],a->a[0],(a,b)->a)).values()

Pruébalo en línea

Julia 0.6 , 36 34 32 bytes

A->values(Dict(y=>x for(x,y)=A))

Pruébalo en línea!

(recortado dos bytes gracias a @JonathanFrech)
(otros dos bytes reemplazando ∈con =comprensión)

El formato de entrada especificado en la pregunta [[1, 2], [2, 7]]funciona como lo es en Julia como una matriz de matrices que contienen pares de valores de clave (potenciales), lo único que hay que tener en cuenta es que la clave ocupa el segundo lugar y el valor primero.

Ligero cambio, para el mismo bytecount,

A->values(Dict((y,x)for(x,y)∈A))

Pruébalo en línea!

Julia 0.6 , 29 26 19 bytes

values∘Dict∘zip

Pruébalo en línea!

Estilo sin puntos. Toma datos como una matriz de claves y una matriz de valores.

Solución anterior:

29 26 bytes

v\k=values(Dict(zip(k,v)))

Pruébalo en línea!

-3 bytes usando la sintaxis del operador en lugar de lambda

Toma datos como una matriz de valores y una matriz de claves.

MATL , 9 bytes

viiQ(5Mu)

Pruébalo en línea!

Probablemente subóptimo, pero bueno, ¡funciona!

Utiliza los hechos de que (a) se garantiza que la entrada solo tiene enteros no negativos, (b) MATL extiende una matriz de intentos de asignar a un índice que no existe.

v - crear una matriz vacía en la pila

i - obtener una matriz de valores

iQ - obtenga una matriz de claves, incremente en 1 (por lo que el valor mínimo es 1, no 0, ya que la indexación MATL se basa en 1)

( - indexación de asignación: use la matriz de claves como índices y asigne los valores a esos índices (si alguna tecla se repite, solo el último valor permanece en esa ubicación)

5M - obtiene la última entrada de la última llamada - que sería la matriz de índices que utilizamos

u) - tome una lista única de esos índices, indexe con esa lista y deje ese resultado (que es una lista de valores de claves únicas) en la pila

Japt , 24 20 16 8 bytes

-4 bytes gracias a @Shaggy

Toma entrada como key, values

â £VgUbX

Pruébalo en línea!

Japt , 20 18 bytes

r@bY <Z?X:XpVgY}[]

Pruébalo en línea!

Pyth , 7 bytes

hMhM.ge

Todos los casos de prueba .

Perl 5 -pa , 24 bytes

%a=@F;$_=join$/,values%a

Pruébalo en línea!

Toma entrada en el formato key value key value key value .... El pie de página de TIO es solo para separar los casos de prueba.

Perl 6 , 25 bytes

{.unique(:as(*[1]))[*;0]}

Intentalo

Expandido:

{  # bare block lambda with implicit parameter $_

  .unique(  # find the unique results (implicit method call on $_)

    :as(    # use this code to compare
      *[1]  # the second value (WhateverCode lambda)
    )

  )[        # index into that
    *;      # all in the top level
    0       # only the first value from each
  ]
}

C-Sharp, 63 bytes

object _(int[][]p)=>p.GroupBy(i=>i[1]).Select(g=>g.First()[0]);

Devuelve un enumerable de enteros.

Wolfram Language (Mathematica) , 25 bytes

#&@@#&@@@#~GatherBy~Last&

Pruébalo en línea!

Óxido , 81 bytes

|a,b|b.zip(a).collect::<std::collections::HashMap<_,_>>().into_iter().map(|v|v.1)

Pruébalo en línea!

Toma dos iteradores, devuelve un iterador.

Perl 6 , 12 bytes

{%$_.values}

Pruébalo en línea!

Convierte la lista dada en un hash y luego devuelve los valores. Esto funciona tanto en una lista de pares como en una lista de key, value, key, value....