Entrada

Faça uma lista dos valores x _i cada um emparelhado com uma tecla y _i .

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

Resultado

Retorne uma lista L contendo apenas valores do conjunto { x _i }.

• O comprimento de L deve ser igual ao número de chaves exclusivas k no conjunto { y _i }.
• Para cada chave exclusiva k , deve haver um valor de { x _i } que tenha a chave k .

Detalhes

• Lacunas padrão não permitidas.
• Você pode assumir que todos os valores na entrada serão números inteiros não negativos.
• Pode haver valores e chaves duplicados.
• Você pode assumir que há pelo menos um par de valor / chave na entrada.
• Se você preferir usar duas listas de tamanho igual como entrada (uma para valores e outra para chaves), tudo bem.
• Você não pode receber nenhuma outra entrada.
• A ordem da lista que você produz não importa.
• O x _{i que} você escolher para cada chave não importa.

Por exemplo, com a entrada [[0, 0], [1, 3], [2, 3]]você pode retornar tanto [0, 1]ou [0, 2]ou qualquer permutação destes.

Exemplos

[[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]

Menos bytes ganha.

Python 2 , 34 bytes

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

Experimente online!

Recebe a entrada como lista de valores e lista de chaves.
Gere dicionário, trocando chaves e valores, o que deixa apenas valores y únicos. Retornar todos os valores x correspondentes

Geléia , 2 bytes

Ḣƙ

Experimente online!

Leva duas listas de igual comprimento, primeiro é as chaves, segundo é os valores.

J , 4 bytes

{./.

Quão?

O argumento da esquerda xé uma lista de chaves, a correta y- uma lista de valores

/.grupos de yacordox

{. pega o primeiro elemento de cada grupo

Experimente online!

Clojure, 20 18 bytes

(comp vals zipmap)

Isso leva listas de valores e chaves como argumentos, nessa ordem.

Python 3 , 42 bytes

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

Experimente online!

a = valores
b = chaves

Haskell , 49 47 bytes

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

Experimente online! Insira como uma lista de tuplas, por exemplo [(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

Experimente online!

JavaScript (ES8), 43 bytes

Recebe entrada como 2 listas distintas na sintaxe de currying (values)(keys).

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

Experimente online!

Casca , 4 bytes

ṁhüt

Experimente online!

Quão?

ühüt - Programa completo. 
  üt - Agrupe por cauda (as listas sem o primeiro elemento).
--h - Mapeie os cabeçalhos (as listas sem o último elemento) e concatene os resultados.

Stax , 5 bytes

╠HB%§

Execute e depure

Leva duas matrizes, primeiro valores e depois chaves.

Explicação:

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

Experimente online!

Japonês , 8 bytes

â £VgUbX

Intérprete Japt

Obrigado a Shaggy por salvar 1 último byte

Completamente reformulada a lógica. Toma algumas pistas da resposta de Luis, mas acho que ainda está melhorada. Agora recebe a entrada como duas listas keys, values,. Aparentemente, ainda estou aquém do ideal.

Explicação:

â £         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

Ruby , 27 bytes

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

Experimente online!

Recebe a entrada como duas matrizes (o rodapé transforma os casos de teste originais nesse formato).

05AB1E , 4 bytes

DÙkè

Tome duas listas de entrada: primeiro os valores e depois as teclas.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Um lambda de um fluxo de int[]pares para java.util.Collection<Integer>.

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

Experimente Online

Julia 0.6 , 36 34 32 bytes

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

Experimente online!

(eliminou dois bytes graças a @JonathanFrech)
(outros dois bytes substituindo∈ por =em compreensão)

O formato de entrada especificado na pergunta [[1, 2], [2, 7]] funciona como em Julia como uma matriz de matrizes contendo pares de valores-chave (potenciais), a única coisa a se cuidar é que a chave fique em segundo e o valor em primeiro lugar.

Pequenas alterações, pelo mesmo número anterior,

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

Experimente online!

Julia 0.6 , 29 26 19 bytes

values∘Dict∘zip

Experimente online!

Estilo sem pontos. Recebe a entrada como uma matriz de chaves e uma matriz de valores.

Solução mais antiga:

29 26 bytes

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

Experimente online!

-3 bytes usando a sintaxe do operador em vez de lambda

Recebe a entrada como uma matriz de valores e uma matriz de chaves.

MATL , 9 bytes

viiQ(5Mu)

Experimente online!

Provavelmente abaixo do ideal, mas ei, funciona!

Usa os fatos de que (a) a entrada é garantida como tendo números inteiros não negativos, (b) o MATL estende uma matriz que você tenta atribuir a um índice que não existe.

v - crie uma matriz vazia na pilha

i - obter matriz de valores

iQ - obtém uma matriz de chaves, incrementa em 1 (então o valor mínimo é 1, não 0, pois a indexação MATL é baseada em 1)

( - indexação de atribuição - use a matriz de chaves como índices e atribua os valores a esses índices (se alguma tecla for repetida, apenas o último valor permanecerá nesse local)

5M - obtém a última entrada da última chamada - que seria a matriz de índices que usamos

u) - pegue uma lista exclusiva desses índices, indexe com essa lista e deixe esse resultado (que é uma lista de valores de chaves exclusivas) na pilha

Japt , 24 20 16 8 bytes

-4 bytes graças a @Shaggy

Aceita entrada como key, values

â £VgUbX

Experimente online!

Japonês , 20 18 bytes

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

Experimente online!

Pitão , 7 bytes

hMhM.ge

Todos os casos de teste .

Perl 5 -pa , 24 bytes

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

Experimente online!

Recebe entrada no formato key value key value key value .... O rodapé do TIO serve apenas para separar os casos de teste.

Perl 6 , 25 bytes

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

Tente

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

Retorna um enumerável de números inteiros.

Wolfram Language (Mathematica) , 25 bytes

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

Experimente online!

Ferrugem , 81 bytes

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

Experimente online!

Toma dois iteradores, retorna um iterador.

Perl 6 , 12 bytes

{%$_.values}

Experimente online!

Coercifica a lista fornecida em um Hash e, em seguida, retorna os valores. Isso funciona tanto em uma lista de pares quanto em uma lista de key, value, key, value....