Étant donné une matrice entière aet un entier non négatif i, sortez un mappage bqui mappe les valeurs distinctes de la ie colonne de asur les lignes de aqui ont cette valeur dans la ie colonne.

Vous pouvez supposer qu'il se itrouve dans la plage semi-ouverte [0, num_cols(a))(ou [1, num_cols(a)]si vous choisissez d'utiliser des indices basés sur 1) et que tous les entiers se trouvent dans la plage représentable de votre langue. L'entrée et la sortie peuvent être effectuées de toute manière raisonnable, tant qu'elles satisfont aux exigences de base du défi (tableau 2D -> mappage des entiers aux tableaux 2D des pouces). Tant que le mappage est clair et cohérent, les clés n'ont pas besoin d'être incluses dans la sortie.

Exemples

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

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

Octave , 24 octets

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

Essayez-le en ligne!

Cela crée une fonction anonyme qui renvoie une matrice dont les lignes correspondent aux critères. Les tableaux d'index d'octave sont à 1, et non à zéro, et les lignes d'une matrice sont séparées par a ;.

Les matrices sont ce qu'Octave fait le mieux - si bien, en fait, que ce défi peut être résolu en utilisant une syntaxe pure, sans fonctions intégrées.

Explication

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

Rubis , 26 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 21 octets

#~GroupBy~Extract@#2&

1 indexé. Renvoie un Associationmappage.

Essayez-le en ligne!

Il s'agit d'un cas rare dans lequel une fonction plus longue ( Extract) réduit le nombre d'octets (la plus courte étant Partou [[ ... ]]) car Extractpeut curry. Le résultat est cette solution à deux fonctions extrêmement concise.

Explication

Extract@#2

Fonction qui extrait le <second input>e élément.

#~GroupBy~ ...

Regroupez les <first input>dans des listes associées à des clés distinctes <above function>[element].

Haskell , 64 60 octets

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

Essayez-le en ligne!

Nettoyer , 40 octets

import StdEnv

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

Essayez-le en ligne!

Un lambda ( :: Int [[Int]] Int -> [[Int]]) où une application partielle des deux premiers arguments seulement donne un mappage sur le troisième argument.

J , 16 octets

-3 octets grâce à FrownyFrog!

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

Essayez-le en ligne!

Explication:

Un verbe dyadique, prenant icomme argument de gauche et acomme argument de droite.

] est le bon argument, a

{"1trouve les nombres dans ila colonne e de chaque ligne

</. encadre les groupes de l'argument de droite, sélectionnés par les touches, fournis par celui de gauche

~.@[ trouve les clés uniques

;"0 relie les clés aux groupes sélectionnés

jq, 100 octets

utilise un objet pour la sortie, prend un argument de ligne de commande $f plus un tableau sur l'entrée standard

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

désobfusqué:

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

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

Essayez-le en ligne!

24 octets rasés par @JayCe

Python 3 , 45 octets

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

Essayez-le en ligne!

Renvoie le mappage représenté comme un lambda anonyme.

Proton , 29 octets

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

Essayez-le en ligne!

-3 octets grâce à M. Xcoder utilisant le curry et filter(TBH je suis un peu surpris que cela ait filterréellement fonctionné)

JavaScript (Node.js) , 29 octets

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

Essayez-le en ligne!

Mis à jour maintenant que je me rends compte des exigences de sortie lâches. Cela utilise le curry comme technique de golf et renvoie également une fonction qui prend une entrée net la mappe vers les tableaux appropriés.

Gelée , 5 octets

ịⱮ⁹¹ƙ

Essayez-le en ligne!

Omet les clés, mais devrait être clair.

Argument 1: i + 1
Argument 2: a

Java 10, 135 64 octets

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

Renvoie une Function<Integer, List<int[]>>acceptation d'une entrée entière n, qui renvoie une liste de tableaux (matrices-lignes) où les i'e valeurs sont égales à la donnée n.

Essayez-le en ligne.

Explication:

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