Dada una matriz entera ay un entero no negativo i, genera un mapeo bque mapea los valores distintos en la icolumna th aa las filas de aquienes tienen ese valor en la icolumna th.

Puede suponer que iestá en el rango medio abierto [0, num_cols(a))(o [1, num_cols(a)]si elige usar índices basados ​​en 1), y que todos los enteros están dentro del rango representable para su idioma. La entrada y la salida pueden realizarse de cualquier manera razonable, siempre que satisfaga los requisitos básicos del desafío (matriz 2D -> mapeo de ints a matrices 2D de ints). Mientras el mapeo sea claro y consistente, las claves no necesitan ser incluidas en la salida.

Ejemplos

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

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Octava , 24 bytes

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

Pruébalo en línea!

Esto crea una función anónima que devuelve una matriz cuyas filas coinciden con los criterios. Octave indexa las matrices en 1, no en cero, y las filas de una matriz están separadas por a ;.

Las matrices son lo que Octave hace mejor, tan bien, de hecho, que este desafío se puede resolver utilizando sintaxis pura, sin funciones integradas.

Explicación

@(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

Rubí , 26 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 21 bytes

#~GroupBy~Extract@#2&

1 indexado. Devuelve un Associationmapeo.

Pruébalo en línea!

Este es un caso raro en el que una función más larga ( Extract) reduce el recuento de bytes (el más corto es Parto [[ ... ]]) porque Extractpuede curry. El resultado es esta solución de dos funciones extremadamente concisa.

Explicación

Extract@#2

Función que extrae el <second input>elemento th.

#~GroupBy~ ...

Agrupe las <first input>listas asociadas con claves 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]

Pruébalo en línea!

Limpio , 40 bytes

import StdEnv

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

Pruébalo en línea!

Un lambda ( :: Int [[Int]] Int -> [[Int]]) donde una aplicación parcial de solo los dos primeros argumentos proporciona una asignación en el tercer argumento.

J , 16 bytes

-3 bytes gracias a FrownyFrog!

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

Pruébalo en línea!

Explicación:

Un verbo diádico, tomando icomo argumento izquierdo y acomo derecho.

] es el argumento correcto a

{"1encuentra los números en ila columna th de cada fila

</. agrupa grupos del argumento derecho, seleccionados por las teclas, proporcionados por el izquierdo

~.@[ encuentra las llaves únicas

;"0 vincula las teclas a los grupos seleccionados

jq, 100 bytes

usa un objeto para la salida, toma un argumento de línea de comando $fmás una matriz en la entrada estándar

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

desobuscado:

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

Pruébalo en línea!

24 bytes recortados por @JayCe

Python 3 , 45 bytes

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

Pruébalo en línea!

Devuelve la asignación representada como una lambda anónima.

Protón , 29 bytes

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

Pruébalo en línea!

-3 bytes gracias al Sr. Xcoder usando curry y filter(TBH, estoy un poco sorprendido de que filterrealmente haya funcionado)

JavaScript (Node.js) , 29 bytes

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

Pruébalo en línea!

Actualizado ahora que me doy cuenta de los requisitos de salida suelta. Esto utiliza el curry como una técnica de golf, y también devuelve una función que toma una entrada ny la asigna a las matrices adecuadas.

Jalea , 5 bytes

ịⱮ⁹¹ƙ

Pruébalo en línea!

Omite las claves, pero debe quedar 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);}}

Devuelve la Function<Integer, List<int[]>>aceptación de una entrada de entero n, que devuelve una Lista de matrices (matrices-filas) donde los ivalores 'th son iguales a los dados n.

Pruébalo en línea.

Explicación:

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