पूर्णांक की एक सूची को देखते हुए, तत्वों को समूह जो सबसे पहले होता है, फिर अगले सबसे और इतने पर समूह बनाते हैं जब तक कि सूची में प्रत्येक अद्वितीय तत्व को एक बार समूहीकृत नहीं किया गया है।

उदाहरण:

इनपुट: [1,2,3]

आउटपुट: [[1,2,3]]

इनपुट: [1,1,1,2,2,3,3,4,5,6]

आउटपुट: [[1],[2,3],[4,5,6]]

इनपुट: [1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56]

आउटपुट: [[6, 8],[5],[1],[7],[9,4,-56]]

इनपुट: []

आउटपुट: []

इनपुट: (empty input)

आउटपुट: ERROR/Undefined/Doesn't matter

नियम

समूहों को अधिकतम आवृत्ति से न्यूनतम आवृत्ति तक जाना चाहिए।
समूहों का आंतरिक क्रम मनमाना है (ईजी उदाहरण 3 [8,6]इसके बजाय हो सकता है )।
यह कोड-गोल्फ , सबसे कम बाइट-काउंट जीत है।

सम्बंधित

किसी सूची के अलग-अलग तत्वों को आवृत्ति द्वारा अवरोही क्रम में क्रमबद्ध करें

code-golf array-manipulation

— जादू ऑक्टोपस Urn
स्रोत

1

क्या आउटपुट स्ट्रिंग प्रारूप में हो सकता है? अर्थात। सूचियों की एक सूची, लेकिन प्रत्येक संख्या एक पूर्णांक के बजाय एक चरित्र द्वारा दर्शाई जाती है।

— mb7744

6

पायथ , 8 7 बाइट्स

_{M.g/Q

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

1 बाइट फ्रायअमईएग्गमैन को धन्यवाद।

— लीक नन
स्रोत

@DigitalTrauma आप नहीं कर सकते हैं; यह एक मेमने में है; निहित चर वहाँ है k, जिसे मैं पहले ही छोड़ चुका हूँ।

— लीक नून

मिल गया - स्पष्टीकरण के लिए धन्यवाद!

— डिजिटल ट्रामा

बधाई हो।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn धन्यवाद।

— लीक नून

7

गणितज्ञ, 43 बाइट्स

Union/@SortBy[l=#,f=-l~Count~#&]~SplitBy~f&

इसे ऑनलाइन आज़माएं! (गणित का उपयोग करना।)

वैकल्पिक रूप से:

SortBy[Union[l=#],f=-l~Count~#&]~SplitBy~f&

— मार्टिन एंडर
स्रोत

5

कोई अंतर्निहित नहीं है?

— मैजिक ऑक्टोपस Urn

है GatherBy, एक विकल्प नहीं यकीन है कि क्योंकि मैं भाषा नहीं जानता।

— मैजिक ऑक्टोपस Urn

1

@carusocomputing यह मूल सूची में तत्वों की पहली घटना के आधार पर समूहों को क्रमबद्ध करता है, इसलिए मुझे अभी भी बाद में समूहों को क्रमबद्ध करना होगा। पहले सूची को क्रमबद्ध करके, मैं एक बाइट को बचा सकता हूं SplitBy( SortByयदि मैं GatherByपहले करता तो वास्तव में अधिक जटिल होता )।

— मार्टिन एंडर

दिलचस्प है, इसलिए "अधिकतम से न्यूनतम तक क्रम में होना चाहिए" गड़बड़ है?

— मैजिक ऑक्टोपस Urn

@carusocomputing बिल्कुल।

— मार्टिन एंडर

5

पायथन 2 , 145 141 बाइट्स

import collections as c,itertools as i;o=lambda n:lambda l:l[n]
print[map(o(0),g)for _,g in i.groupby(c.Counter(input()).most_common(),o(1))]

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

वर्षों के पढ़ने के बाद यह मेरा पहला सबमिशन है।

यह मूल रूप से यह सभी तत्वों को एक काउंटर में डालता है (सूची में प्रत्येक तत्व के कितने का शब्दकोश) और .AST_common () आवृत्ति क्रम में वस्तुओं को डालता है। उसके बाद, यह केवल वस्तुओं को सही सूची में स्वरूपित करने की बात है।

सहेजा गया 4 बाइट्स ओव्स के लिए धन्यवाद ।

— सनी पटेल
स्रोत

4

PPCG :) में आपका स्वागत है। जैसा मैंने किया वैसा नशा न करें।

— मैजिक ऑक्टोपस Urn

अपना स्वयं का आइटम बनाने वाला फ़ंक्शन इसे आयात करने की तुलना में 4 बाइट्स छोटा होता है:o=lambda n:lambda l:l[n]

— अंडा

5

जावास्क्रिप्ट (ईएस 6), 95 101 बाइट्स

a=>a.map(x=>(o[a.map(y=>n+=x!=y,n=0)|n]=o[n]||[])[x*x+(x>0)]=x,o=[])&&(F=o=>o.filter(a=>a))(o).map(F)

कैसे?

के लिए प्रत्येक तत्व एक्स इनपुट सरणी के एक , हम संख्या की गणना n के तत्वों में से एक है कि से अलग हैं एक्स :

a.map(y => n += x != y, n = 0) | n

हम सरणी o को भरने के लिए सूचकांक n और x का उपयोग करते हैं :

(o[n] = o[n] || [])[x * x + (x > 0)] = x

संपादित करें : क्योंकि JS नकारात्मक सरणी सूचकांकों का समर्थन नहीं करता है, हमें x * x + (x > 0)सकारात्मक सूचकांकों को बाध्य करने के लिए सूत्र की आवश्यकता है ।

यह हमें मूल सूची के अनूठे तत्वों से युक्त सारणियों की एक सरणी देता है, आवृत्ति द्वारा समूहीकृत और अक्सर सबसे कम से कम लगातार आदेश दिया जाता है।

हालाँकि, बाहरी सरणी और आंतरिक सरणियों दोनों में संभावित रूप से कई खाली स्लॉट हैं जिन्हें हम फ़िल्टर करना चाहते हैं। हम यह कार्य F के साथ करते हैं , जो o और उसके प्रत्येक तत्व पर लागू होता है :

F = o => o.filter(a => a)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>a.map(x=>(o[a.map(y=>n+=x!=y,n=0)|n]=o[n]||[])[x*x+(x>0)]=x,o=[])&&(F=o=>o.filter(a=>a))(o).map(F)

console.log(JSON.stringify(f([1,2,3]))) // [[1,2,3]]
console.log(JSON.stringify(f([1,1,1,2,2,3,3,4,5,6]))) // [[1],[2,3],[4,5,6]]
console.log(JSON.stringify(f([1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56]))) // [[6, 8],[5],[1],[7],[9,4,-56]]
console.log(JSON.stringify(f([]))) // []

स्निपेट का विस्तार करें

— Arnauld
स्रोत

मुझे लगता है कि Setआप एक बाइट बचाता है a=>a.map(e=>(r[n=0,a.map(f=>n+=e!=f),n]||(r[n]=new Set)).add(e),r=[])&&r.filter(s=>s).map(s=>[...s]):।

— नील

@ नील यह मेरे वर्तमान दृष्टिकोण से काफी अलग है। शायद आपको इसे एक नए उत्तर के रूप में पोस्ट करना चाहिए?

— अरनुलद

मुझे नहीं लगा कि o[n]एक एरे से सेट पर बदलना अलग बात थी, लेकिन मैंने पहले ही @ रिकहिचॉक के जवाब को पहले ही गवा दिया था, इसलिए इसमें ज्यादा दम नहीं है।

— नील

3

PHP , 85 बाइट्स

<?$r=[];foreach(array_count_values($_GET)as$k=>$v)$r[$v][]=$k;krsort($r);print_r($r);

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

— जार्ग हुल्सरमन
स्रोत

3

जेली , ९ by बाइट्स

QɓċÐ€ĠṚị

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

— डेनिस
स्रोत

5

क्या ... अजगर ... हरा ... जेली?

— लीक नून

1

जेली के पास ग्रुप-बाय नहीं है, इसलिए आश्चर्य नहीं होना चाहिए।

— डेनिस

2

क्लोजर, 74 बाइट्स

#(for[[_ g](sort-by(comp - key)(group-by val(frequencies %)))](map key g))

काफी क्रियात्मक लगता है: /

— NikoNyrh
स्रोत

मुझे इसे मारो (और मुझे कुछ बाइट्स से हरा दें, comp -रिवर्स का चतुर उपयोग !)। अन्य भाषाओं की तरह कम नहीं है, लेकिन मुझे लगा कि यह मनोरंजक था क्योंकि क्लोजर में "ग्रुप-बाय" और "फ्रीक्वेंसी" का निर्माण किया गया है।

— मैटपुतनम

जब मैंने कार्य विवरण पढ़ा तो मैं 50 या 60 बाइट्स की उम्मीद कर रहा था, लेकिन वास्तविक कार्यान्वयन थोड़ा पेचीदा हो गया।

— निकोनिरह

2

पर्ल 6 , 43 बाइट्स

*.Bag.classify(-*.value).sort».value».key

झसे आज़माओ

विस्तारित:

*                   # WhateverCode lambda (this is the input)
                    # [1,1,1,2,2,3,3,4,5,6]

.Bag                # turn into a Bag
                    # (1=>3,5=>1,4=>1,3=>2,6=>1,2=>2).Bag

.classify(-*.value) # classify by how many times each was seen
                    # {-2=>[3=>2,2=>2],-3=>[1=>3],-1=>[5=>1,4=>1,6=>1]}

.sort\              # sort (this is why the above is negative)
                    # {-3=>[1=>3],-2=>[3=>2,2=>2],-1=>[5=>1,4=>1,6=>1]}

».value\            # throw out the classification
                    # ([1=>3],[3=>2,2=>2],[5=>1,4=>1,6=>1])

».key               # throw out the counts
                    # ([1],[3,2],[5,4,6])

— ब्रैड गिल्बर्ट b2gills
स्रोत

वाह, मैं हमेशा के बारे में भूल जाओ Bag, अच्छा एक!

— मैजिक ऑक्टोपस Urn

2

बैश + जीएनयू उपयोगिताओं, 71 61

sort|uniq -c|sort -nr|awk '{printf$1-a?"\n%d":",%d",$2;a=$1}'

एक नईलाइन-सीमांकित सूची के रूप में इनपुट। अल्पविराम से अलग किए गए मानों की एक नई-सीमांकित सूची के रूप में आउटपुट।

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

— डिजिटल आघात
स्रोत

2

MATL , 9 बाइट्स

9B#uw3XQP

इनपुट एक स्तंभ वेक्टर है, जो ;विभाजक के रूप में उपयोग करता है।

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

व्याख्या

9B#u   % Call 'unique' function with first and fourth outputs: unique entries and
       % number of occurrences
w      % Swap
3XQ    % Call 'accumarray' with anonymous function @(x){sort(x).'}. The output is
       % a cell array with the elements of the input grouped by their frequency.
       % Cells are sorted by increasing frequency. Some cells may be empty, but
       % those won't be displayed
P      % Flip cell array, so that groups with higher frequency appear first.
       % Implicitly display

— लुइस मेंडो
स्रोत

2

k, 22 बाइट्स

{x@!x}{(>x)@=x@>x}#:'=

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

^{( ऐडवर्ड्स के लिए @पहले एक अतिरिक्त की आवश्यकता लगती है #, लेकिन ओके नहीं।)}

स्पष्टीकरण:

                     = /group identical numbers in a map/dict
                  #:'  /get number of times each number is repeated
                       /this is almost the answer, but without the inner lists
      {      x@>x}     /order "number of times" greatest to least
            =          /group them (to make the smaller groups)
       (>x)@           /get the actual numbers into place
{x@!x}                 /get values of the map/dict it's in

— zgrep
स्रोत

github.com/JohnEarnest/ok किसी और के लिए सोच रहा है कि kयह वास्तव में क्या है ok। Ba-dum-tssss ...

— मैजिक ऑक्टोपस Urn

2

ब्रेकीलॉग , 10 बाइट्स

ọtᵒ¹tᵍhᵐ²|

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

व्याख्या

Example input: [2,1,1,3]

ọ            Occurences:            [[2,1],[1,2],[3,1]]
 tᵒ¹         Order desc. by tail:   [[1,2],[3,1],[2,1]]
    tᵍ       Group by tail:         [[[1,2]],[[3,1],[2,1]]]
      hᵐ²    Map twice head:        [[1],[3,2]]

         |   Else (Input = [])      Input = Output

— Fatalize
स्रोत

2

मैथेमेटिका, 79 बाइट्स

Table[#&@@@f[[i]],{i,Length[f=GatherBy[Sort[Tally@#,#1[[2]]>#2[[2]]&],Last]]}]&

इनपुट

[{1, 1, 1, 4, 5, 6, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 5, 6, 5, 6, 5, 6, 5, 6, -56}]

उत्पादन

{{8, 6}, {5}, {1}, {7}, {-56, 9, 4}}

— J42161217
स्रोत

GatherBy मैंने मार्टिन का उल्लेख किया! मैं सोच रहा था कि यह कैसे होगा :)।

— मैजिक ऑक्टोपस Urn

Sort[...,...&]बस है SortBy[...,-Last@#&]।

— मार्टिन एंडर

Length[f=...]। और First/@है #&@@@।

— मार्टिन एंडर

निश्चित, नियत और निश्चित

— J42161217

2

आर , 84 77 बाइट्स

-7 बाइट्स mb7744 के लिए धन्यवाद

unique(lapply(x<-sort(table(scan()),T),function(y)as.double(names(x[x==y]))))

स्टड से पढ़ता है; बढ़ते क्रम में पूर्णांकों के उप-डॉक्टरों के साथ एक सूची देता है। यदि हम ints के बजाय स्ट्रिंग्स को वापस कर सकते हैं, तो मैं 11 बाइट्स (कॉल को हटाकर as.double) छोड़ सकता हूं , लेकिन इसके बारे में है। आर का tableकार्य यहां भारी लिफ्टिंग करता है, इसके इनपुट के प्रत्येक सदस्य की घटनाओं की गणना करता है; तब यह उन्हें गणना द्वारा एकत्र करता है ( names)। बेशक, यह एक स्ट्रिंग है, इसलिए हमें इसे एक पूर्णांक / डबल तक पहुंचाना होगा।

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

— ग्यूसेप
स्रोत

आप "जो" को समाप्त करके 7 बाइट्स खो सकते हैं, और तार्किक अनुक्रमण का उपयोग कर सकते हैं

— mb7744

@ mb7744 ओह दुह।

— ग्यूसेप

1

मैंने आर के साथ एक और छुरा लिया। यह दुर्भाग्यपूर्ण है कि लंबोदर सिंटैक्स कितना लंबा है, इसलिए मैंने इसे टालने की कोशिश की। बदले में मुझे नेस्टेड का उपयोग करना था lapply, लेकिन कम से कम उस मामले में मैं एक छोटे चर को असाइन कर सकता हूं lapply। मैं फ़ंक्शन को एक चर असाइन नहीं कर सकता function...

— mb7744

2

जावास्क्रिप्ट (ईएस 6), 100 98 96 93 बाइट्स

@ ब्यूटिल के लिए 2 बाइट्स को सहेजा गया (साथ ही उसने मेरे कोड में एक एज-केस बग तय किया)। @TomasLangkaas के लिए 3 और बाइट्स को सहेजा गया।

a=>a.sort().map((_,n)=>a.filter((v,i)=>i-a.indexOf(v)==n&v!=a[i+1])).filter(a=>a+a).reverse()

परीक्षण के मामलों

f=
a=>a.sort().map((_,n)=>a.filter((v,i)=>i-a.indexOf(v)==n&v!=a[i+1])).filter(a=>a+a).reverse()

console.log(JSON.stringify(f([1,2,3])))
console.log(JSON.stringify(f([1,1,1,2,2,3,3,4,5,6])))
console.log(JSON.stringify(f([1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56])))
console.log(JSON.stringify(f([])))

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

आपका परीक्षण त्रुटिपूर्ण है (शून्य के लिए काम नहीं करता है), लेकिन मुझे लगता है कि आप अभी भी बाइट्स को अनइंस्टॉल करने के बजाय फ़िल्टर करके और उलट कर बचा सकते हैं a=>a.sort().map((_,n)=>a.filter((v,i)=>i-a.indexOf(v)==n&v!=a[i+1])).filter(a=>1/a[0]).reverse():।

— नील

आह, मुझे 0 के लिए परीक्षण करने के लिए जाना चाहिए! आपका कोड इसे ठीक करता है, साथ ही यह छोटा है, इसलिए इसके लिए आपको धन्यवाद

— रिक हिचकॉक

सहेजें 3 अधिक बदलकर बाइट्स .filter(a=>1/a[0])करने के लिए .filter(a=>''+a)।

— टॉमस लैंगकास

अच्छा लगा, @TomasLangkaas, धन्यवाद। (2 बाइट्स बचाता है।)

— रिक हिचकॉक

मेरा बुरा (गिनती के साथ परेशानी है), लेकिन .filter(a=>a+a)अतिरिक्त बाइट प्रदान करेगा।

— टॉमस लैंगकास

1

वी , 60 , 54 बाइट्स

ÚòÍ¨¼¾©î±/± ±òHòø 
pkJjòú!
Ç¨^ƒ ©î±/o
Îf ld|;D
òV{Jk

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

Hexdump:

00000000: daf2 cda8 bc81 bea9 eeb1 2fb1 20b1 f248  ........../. ..H
00000010: f2f8 200a 706b 4a6a f2fa 210a c7a8 5e83  .. .pkJj..!...^.
00000020: 20a9 81ee b12f 6f0a ce66 206c 647c 3b44   ..../o..f ld|;D
00000030: 0af2 567b 4a6b                           ..V{Jk

जितना मैं वी से प्यार करता हूं, मुझे पूरा यकीन है कि यह कार्य के लिए सबसे खराब संभव भाषा है। विशेष रूप से यह देखते हुए कि सूची के लिए कोई समर्थन नहीं है, और मूल रूप से संख्याओं के लिए कोई समर्थन नहीं है। बस स्ट्रिंग हेरफेर।

— DJMcMayhem
स्रोत

1

सी #, 119 बाइट्स

बस एक त्वरित छुरा:

using System.Linq;
a=>a.GroupBy(x=>x)
    .GroupBy(x=>x.Count(),x=>x.Key)
    .OrderBy(x=>-x.Key)
    .Select(x=>x.ToArray())
    .ToArray()

— हाथ-ए-खाना
स्रोत

2

+1 हालांकि , आप इसे हटा सकते हैं System.Func<int[],int[][]>F=और पीछे छोड़ सकते हैं ;। यह इस तरह के लैंबडों के लिए बाइट-काउंट का हिस्सा नहीं है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन, मुझे कुछ पता नहीं था। धन्यवाद!

— हाथ-ई-फूड

1

आर , 66 बाइट्स

(l=lapply)(l(split(x<-table(scan()),factor(-x)),names),as.integer)

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

यदि आउटपुट में पूर्णांक स्ट्रिंग प्रारूप में हो सकते हैं, तो 48 बाइट्स तक गिर सकते हैं (जैसा कि @ Giuseppe के उत्तर में बताया गया है)।

Ungolfed:

input <- scan(); # read input
x <- table(input); # count how many times each integer appears, in a named vector
y <- split(x, factor(-x)) # split the count into lists in increasing order
z <- lapply(y, names) # access the the original values which are still
                      # attached via the names
lapply(z, as.integer) # convert the names back to integers

— mb7744
स्रोत

as.doubleएक बाइट से छोटा होता है, और इसे उसी तरह काम करना चाहिएas.integer

— Giuseppe

खैर, यह निर्भर करता है कि आप एक पूर्णांक या एक डबल लौटना चाहते हैं या नहीं। यदि डबल ठीक है, तो शायद चरित्र भी होगा, और हम दोनों कुछ बाइट्स बचा सकते हैं।

— mb7744

1

पॉवरशेल, ~~77,~~ 70 बाइट्स

($a=$args)|group{($a-eq$_).count}|sort n* -Des|%{,($_.group|sort -u)}

एनबी: यह देखने के लिए कि ये परिणाम सही तरीके से समूहीकृत हैं (चूंकि नेत्रहीन प्रत्येक सरणी की सामग्री के बीच कोई परिसीमन नहीं है), आप | write-hostउपरोक्त पंक्ति के अंत में संलग्न करना चाह सकते हैं ।

स्वीकृतियाँ

करने के लिए धन्यवाद:

TessellatingHeckler बड़े पैमाने पर दृष्टिकोण के लिए 7 बाइट्स को बचाने के लिए एक तरह से अधिक गोल्फ दृष्टिकोण के लिए पुनर्लेखन।

पिछला

77 बाइट्स

param($x)$x|group|sort count -desc|group count|%{,($_.group|%{$_.group[0]})}

— JohnLBevan
स्रोत

अच्छा धन्यवाद। मुझे ,()समूहीकरण के लिए टोलकुलाइज करना पड़ा (क्योंकि आउटपुट सिर्फ एक निरंतर सरणी के रूप में दिखा रहा था)। यह मेरे मूल प्रयास की तुलना में अधिक गोल्फ है; अद्भुत कार्य!

— जॉनलेवन

0

ग्रूवी, 71 बाइट्स

{a->a.groupBy{a.count(it)}.sort{-it.key}.values().collect{it.unique()}}

मैंने वास्तव में इसे बनाने के बाद ग्रुपबी के बारे में सीखा। मुझे नहीं पता था कि कलेक्ट करना मेरा एकमात्र विकल्प नहीं था।

{
    a->                 // [1,2,1,2,3,3,3,6,5,4]
    a.groupBy{      
        a.count(it)     // [2:[1,2,1,2],3:[3,3,3],1:[6,5,4]]
    }.sort{             
        -it.key         // [3:[3,3,3],2:[1,2,1,2],1:[6,5,4]]
    }.values().collect{ // [[3,3,3],[1,2,1,2],[6,5,4]]
        it.unique()
    }                   // [[3],[1,2],[6,5,4]]
}

— जादू ऑक्टोपस Urn
स्रोत

0

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

->a{a.group_by{|e|a.count(e)}.sort_by{|x,_|-x}.map{|_,i|i|[]}}

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

ऐसा करने के लिए एक छोटा तरीका होना चाहिए।

— canhascodez
स्रोत

फ़्रिक्वेंसी द्वारा समूह सूची

उदाहरण:

नियम

सम्बंधित

पायथ , 8 7 बाइट्स

गणितज्ञ, 43 बाइट्स

पायथन 2 , 145 141 बाइट्स

जावास्क्रिप्ट (ईएस 6), 95 101 बाइट्स

कैसे?

परीक्षण के मामलों

PHP , 85 बाइट्स

जेली , ९ by बाइट्स

क्लोजर, 74 बाइट्स

पर्ल 6 , 43 बाइट्स

विस्तारित:

बैश + जीएनयू उपयोगिताओं, 71 61

MATL , 9 बाइट्स

व्याख्या

k, 22 बाइट्स

ब्रेकीलॉग , 10 बाइट्स

व्याख्या

मैथेमेटिका, 79 बाइट्स

आर , 84 77 बाइट्स

जावास्क्रिप्ट (ईएस 6), 100 98 96 93 बाइट्स

वी , 60 , 54 बाइट्स

सी #, 119 बाइट्स

आर , 66 बाइट्स

ग्रूवी, 71 बाइट्स

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