Dada uma matriz inteira ae um inteiro não negativo i, produz um mapeamento bque mapeia os valores distintos na ith coluna de apara linhas de aquem tem esse valor na ith coluna.

Você pode assumir que iestá no intervalo semi-aberto [0, num_cols(a))(ou [1, num_cols(a)]se você optar por usar índices baseados em 1) e que todos os números inteiros estão dentro do intervalo representável para o seu idioma. A entrada e a saída podem ser feitas de qualquer maneira razoável, desde que atenda aos requisitos básicos do desafio (matriz 2D -> mapeamento de entradas para matrizes 2D de entradas). Desde que o mapeamento seja claro e consistente, as chaves não precisam ser incluídas na saída.

Exemplos

[[1]], 0 -> {1: [[1]]}
[[3, 4, 5], [1, 4, 2], [5, 5, 5], [7, 7, 7], [1, 5, 9]], 1 -> {4: [[3, 4, 5], [1, 4, 2]], 5: [[5, 5, 5], [1, 5, 9]], 7: [[7, 7, 7]]}
[[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [2, 3, 4, 5, 6], [8, 9, 100, 0, 2]], 4 -> {5: [[1, 2, 3, 4, 5]], 1: [[5, 4, 3, 2, 1]], 6: [[2, 3, 4, 5, 6]], 2: [[8, 9, 100, 0, 2]]}

Isso é código-golfe , então a resposta mais curta em bytes vence.

Oitava , 24 bytes

@(a,i)@(n)a(a(:,i)==n,:)

Experimente online!

Isso cria uma função anônima que retorna uma matriz cujas linhas correspondem aos critérios. Índices de oitava matrizes em 1, e não zero, e as linhas de uma matriz são separadas por a ;.

Matrizes são o que o Octave faz melhor - tão bem que, na verdade, esse desafio pode ser resolvido usando a sintaxe pura, sem funções internas.

Explicação

@(a,i)                   % creates an anonymous function that...
      @(n)               % returns another function that takes input n and
                         % maps it to the rows of a.
          a(         ,:) % Return all the columns of a, with the rows filtered by...
            a(:,i)       % whether the ith column of each row of a...
                  ==n    % equals n

Ruby , 26 bytes

->a,i{a.group_by{|x|x[i]}}

Experimente online!

Wolfram Language (Mathematica) , 21 bytes

#~GroupBy~Extract@#2&

1 indexado. Retorna um Associationmapeamento.

Experimente online!

Este é um caso raro em que uma função mais longa ( Extract) reduz a contagem de bytes (sendo a mais curta Partou [[ ... ]]) porque Extractpode curry. O resultado é esta solução de duas funções extremamente concisa.

Explicação

Extract@#2

Função que extrai o <second input>elemento th.

#~GroupBy~ ...

Agrupe as <first input>listas em associadas a chaves distintas <above function>[element].

Haskell , 64 60 bytes

import Data.List
i!l=[(k,[a|a<-l,a!!i==k])|k<-nub$map(!!i)l]

Experimente online!

Limpo , 40 bytes

import StdEnv

\n l i=filter(\a=a!!n==i)l

Experimente online!

Um lambda ( :: Int [[Int]] Int -> [[Int]]) onde uma aplicação parcial dos dois primeiros argumentos fornece um mapeamento no terceiro argumento.

J , 16 bytes

-3 bytes graças ao FrownyFrog!

{"1(~.@[;"0</.)]

Experimente online!

Explicação:

Um verbo diádico, tendo icomo argumento esquerdo e acomo direito.

] é o argumento certo, a

{"1localiza os números na icoluna th em cada linha

</. grupos de caixas do argumento da direita, selecionado pelas teclas, fornecido pela esquerda

~.@[ encontra as chaves exclusivas

;"0 vincula as chaves aos grupos selecionados

jq, 100 bytes

usa um objeto para saída, usa um argumento de linha de comando $fmais uma matriz na entrada padrão

([.[]|.[$f]]|unique) as $c|[$c[] as $d|{($d|tostring):([.[]|[select(.[$f]==$d)]]|add)}]|add

desofuscada:

.fieldnum as $field |
.input as $input |
([$input[] | .[$field]] | unique) as $categories |
[
    $categories[] as $category |
    {
        ($category | tostring) :
            ([$input[] | [select(.[$field]==$category)]] | add)
    }
] | add

R , 79 55 bytes

function(a,i)for(z in unique(a[,i]))print(a[a[,i]==z,])

Experimente online!

24 bytes eliminados por @JayCe

Python 3 , 45 bytes

lambda a,i:lambda n:[r for r in a if r[i]==n]

Experimente online!

Retorna o mapeamento representado como uma lambda anônima.

Próton , 29 bytes

a=>i=>n=>filter(r=>r[i]==n,a)

Experimente online!

-3 bytes, graças ao Sr. Xcoder usando curry e filter(TBH, estou meio surpreso que filterrealmente funcionou)

JavaScript (Node.js) , 29 bytes

a=>i=>n=>a.filter(e=>e[i]==n)

Experimente online!

Atualizado agora que percebo os requisitos de saída soltos. Isso usa o curry como uma técnica de golfe e também retorna uma função que leva uma entrada ne mapeia isso para as matrizes apropriadas.

Gelatina , 5 bytes

ịⱮ⁹¹ƙ

Experimente online!

Omite as teclas, mas deve estar claro.

Argumento 1: i + 1
Argumento 2: a

Java 10, 135 64 bytes

m->i->n->new java.util.Stack(){{for(var a:m)if(a[i]==n)add(a);}}

Retorna a Function<Integer, List<int[]>>aceitação de uma entrada de número inteiro n, que retorna uma Lista de matrizes (linhas da matriz) em que os ivalores são iguais aos dadosn .

Experimente online.

Explicação:

m->i->               // Method with int-matrix and int parameters and Function return-type
  n->                //  Return a Function with integer as parameter
    new java.util.Stack(){{
                     //  and List of integer-arrays as return-type
      for(var a:m)   //   Loop over the arrays of the input-matrix
        if(a[i]==n)  //    If the `i`'the value of the current array equals `n`:
          add(a);}}  //     Add it to the return-List