ग्रुपिंग एरे डेटा

Question

एक पूर्णांक मैट्रिक्स को देखते हुए aऔर ग़ैर-ऋणात्मक पूर्णांक i, उत्पादन एक मानचित्रण bकि में अलग-अलग मान नक्शे iका वें स्तंभ aकी पंक्तियों के लिए aजो कि मूल्य iवें स्तंभ।

आप मान सकते हैं कि iयह अर्ध-खुली सीमा में है [0, num_cols(a))(या [1, num_cols(a)]यदि आप 1-आधारित सूचकांकों का उपयोग करना चुनते हैं), और यह कि सभी पूर्णांक आपकी भाषा के लिए प्रतिनिधित्व करने योग्य सीमा के भीतर हैं। इनपुट और आउटपुट किसी भी उचित तरीके से किया जा सकता है, इसलिए जब तक यह चुनौती की बुनियादी आवश्यकताओं (2 डी सरणी -> इन्ट्स से 2 डी सरणियों में मैपिंग) को संतुष्ट करता है। जब तक मैपिंग स्पष्ट और सुसंगत है, तब तक कुंजियों को आउटपुट में शामिल करने की आवश्यकता नहीं है।

उदाहरण

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

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

Comments

सैंडबॉक्स

— मेगो

बस जाँच करने के लिए, मैपिंग एक फ़ंक्शन हो सकता है? मुझे पता नहीं है कि क्या यह एक डिफ़ॉल्ट है, लेकिन ऐसा लगता है कि कुछ ऐसा है जिसे आप अनुमति देना चाहते हैं।

— फ्राईमईएग्गमैन

@FryAmTheEggman हाँ, एक फ़ंक्शन जो हमारी सामान्य आवश्यकताओं को पूरा करता है उसे अनुमति दी जाती है। I / O बेहद लचीला है।

— मेगो

मुझे यह I / O प्रारूप बहुत पसंद है क्योंकि आउटपुट को वास्तव में इनपुट को अपने आप में रखने की आवश्यकता नहीं है। जब तक फ़ंक्शन मैपिंग न हो, तब तक किसी फ़ंक्शन को संदर्भ द्वारा इनपुट तक पहुंचना पूरी तरह से ठीक है।

— जुंगवान मिन

@JungHwanMin मुझे खुशी है। मैं एक बहुत ही ढीले I / O प्रारूप के साथ प्रयोग करना चाहता था, और यह अब तक अच्छी तरह से चल रहा है

— मेगो

Answer 1

ऑक्टेव , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह एक अनाम फ़ंक्शन बनाता है जो एक मैट्रिक्स लौटाता है जिसकी पंक्तियां मानदंडों से मेल खाती हैं। 1 पर ऑक्टेव इंडेक्स एरेस है, शून्य नहीं है, और मैट्रिक्स की पंक्तियों को ए द्वारा अलग किया जाता है ;।

मैट्रिक्स वे हैं जो ऑक्टेव सबसे अच्छा करते हैं - वास्तव में, यह कि शुद्ध सिंटैक्स का उपयोग करके इस चुनौती को हल किया जा सकता है, कोई अंतर्निहित कार्य नहीं।

व्याख्या

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

Answer 2

रूबी , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 21 बाइट्स

#~GroupBy~Extract@#2&

1 अनुक्रमित। एक Associationमैपिंग देता है ।

इसे ऑनलाइन आज़माएं!

यह एक दुर्लभ मामला है जिसमें एक लंबा कार्य ( Extract) बाइट की संख्या को कम करता है (छोटा होने Partया [[ ... ]]) क्योंकि Extractकरी कर सकते हैं। परिणाम यह अत्यंत संक्षिप्त दो-कार्य समाधान है।

व्याख्या

Extract@#2

फ़ंक्शन जो <second input>वें तत्व को निकालता है ।

#~GroupBy~ ...

<first input>अलग-अलग कुंजियों से जुड़ी सूचियों में समूह बनाएं <above function>[element]।

Answer 4

हास्केल , 64 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

साफ , 40 बाइट्स

import StdEnv

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

इसे ऑनलाइन आज़माएं!

एक लैम्ब्डा ( :: Int [[Int]] Int -> [[Int]]) जहां पहले दो तर्कों का एक आंशिक अनुप्रयोग तीसरे तर्क पर एक मानचित्रण देता है।

Answer 6

जे , 16 बाइट्स

-3 बाइट्स FrownyFrog के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

एक रंग क्रिया, iइसके बाएं तर्क के aरूप में और इसके दाईं ओर के रूप में।

] सही तर्क है, a

{"1iप्रत्येक पंक्ति पर वें कॉलम में संख्याओं को पाता है

</. सही तर्क से बक्से समूह, कुंजी द्वारा चयनित, बाईं ओर द्वारा प्रदान किए गए

~.@[ अद्वितीय कुंजी पाता है

;"0 चयनित समूहों की कुंजियों को जोड़ता है

Comments

;"0,:3 की बचत के बजाय

— FrownyFrog

@FrownyFrog बेशक! मुझे लगता है कि मैंने इसकी कोशिश की, लेकिन जाहिर तौर पर सही तरीका नहीं है।

— गैलेन इवानोव

Answer 7

jq, 100 बाइट्स

आउटपुट के लिए एक ऑब्जेक्ट का उपयोग करता है, एक कमांड लाइन तर्क लेता है $fऔर मानक इनपुट पर एक सरणी देता है

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

deobfuscated:

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

Comments

क्या यह वह भाषा है जिसका आप उपयोग कर रहे हैं?

— Οurous

Answer 8

आर , 79 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

24 बाइट्स @JayCe ने मुंडवा दी

Comments

अधिक सीधे निकालने के द्वारा कुछ बाइट्स बचाएं । आप cat(z)कुंजी प्रिंट करने के लिए पहले एक प्रिंट भी जोड़ सकते हैं (यदि यह आवश्यक है तो मैं स्पष्ट नहीं हूं)

— JayCe

Answer 9

पायथन 3 , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनाम लैम्ब्डा के रूप में प्रतिनिधित्व मैपिंग देता है।

Answer 10

प्रोटॉन , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-3 बाइट्स श्री Xcoder के लिए धन्यवाद का उपयोग करी और filter(TBH मुझे आश्चर्य है कि filterवास्तव में काम किया है की तरह)

Comments

करीना औरfilter आप तीन बाइट्स बचाओ का उपयोग कर ।

— मिस्टर एक्सकोडर

@ Mr.Xcoder कूल, धन्यवाद: D

— HyperNeutrino

Answer 11

जावास्क्रिप्ट (Node.js) , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अब अद्यतन किया गया है कि मुझे ढीले आउटपुट आवश्यकताओं का एहसास है। यह एक गोल्फ तकनीक के रूप में करी का उपयोग करता है, और यह एक फ़ंक्शन भी देता है जो एक इनपुट लेता है nऔर उचित सरणियों को मैप करता है।

Answer 12

जेली , 5 बाइट्स

ịⱮ⁹¹ƙ

इसे ऑनलाइन आज़माएं!

चाबियाँ ओमित करता है, लेकिन स्पष्ट होना चाहिए।

तर्क 1: i + 1
तर्क 2: ए

Comments

मुझे नहीं लगता कि यह कुंजी के बिना मानचित्रण के रूप में योग्य होगा।

— डेनिस

@ डेनिस हम्म, मैंने इसके बारे में टिप्पणियों में पूछा था और ओपी ने कहा कि हम चाबियों को छोड़ सकते हैं (वास्तव में मैंने इस सवाल का क्या संपादन किया है), और मैंने इस समाधान को भी वहां जोड़ा था (शायद इतनी जल्दी झंडी नहीं देनी चाहिए थी ... )। मैंने इस उत्तर के पिछले संशोधन (उत्तर की प्रतीक्षा) में कुंजियों को शामिल किया था, इसलिए मैं सिर्फ एक और टिप्पणी पोस्ट करूंगा और देखते हैं कि ओपी क्या कहता है।

— बजे एरिक

Answer 13

जावा 10, 135 64 बाइट्स

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

Function<Integer, List<int[]>>एक पूर्णांक-इनपुट को स्वीकार करते हुए लौटाता है n, जो सूची (मैट्रिक्स-पंक्तियों) की एक सूची लौटाता है, जहां i'वें दिए गए मानों के बराबर है 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