ফ্রিকোয়েন্সি অনুসারে একটি তালিকা গ্রুপ করুন

Question

পূর্ণসংখ্যার একটি তালিকা দেওয়া, যে উপাদানগুলির মধ্যে সর্বাধিক ঘটে সেগুলি গোষ্ঠীভুক্ত করুন, তারপরে পরবর্তী সর্বাধিক গোষ্ঠীভুক্ত করুন এবং যতক্ষণ না তালিকার প্রতিটি অনন্য উপাদান একবারে গোষ্ঠীভূত না হয়।

---

উদাহরণ:

ইনপুট: [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

---

বিধি

• গ্রুপিংগুলি অবশ্যই সর্বোচ্চ ফ্রিকোয়েন্সি থেকে ন্যূনতম ফ্রিকোয়েন্সিতে যেতে হবে।
• গোষ্ঠীগুলির অভ্যন্তরীণ ক্রমটি নির্বিচারে হয় (EG উদাহরণ 3 এর [8,6]পরিবর্তে থাকতে পারে )।
• এটি কোড-গল্ফ , সর্বনিম্ন বাইট-কাউন্ট জেতা।

সম্পর্কিত

• ক্রয়ের ফ্রিকোয়েন্সি অনুসারে একটি উত্থাপিত ক্রমের তালিকার স্বতন্ত্র উপাদানগুলি সাজান

Comments

আউটপুট স্ট্রিং বিন্যাসে হতে পারে? অর্থাৎ। তালিকার একটি তালিকা, তবে প্রতিটি সংখ্যা পূর্ণসংখ্যার পরিবর্তে একটি অক্ষর দ্বারা প্রতিনিধিত্ব করে।

— mb7744

Answer 1

পাইথ , 8 7 বাইট

_{M.g/Q

এটি অনলাইন চেষ্টা করুন!

1 বাইট FryAmTheEggman ধন্যবাদ।

Comments

@ ডিজিটাল ট্রামুমা আপনি পারবেন না; এটি একটি ল্যাম্বডায়; অন্তর্নিহিত ভেরিয়েবলটি রয়েছে k, যা আমি ইতিমধ্যে বাদ দিয়েছি।

— ফাঁস নুন

এটি পেয়েছি - ব্যাখ্যা জন্য ধন্যবাদ!

— ডিজিটাল ট্রমা

অভিনন্দন।

— ম্যাজিক অক্টোপাস উরন 21

@ ম্যাজিক অ্যাক্টোপাস ইউরন আপনাকে ধন্যবাদ।

— লিকি নুন

Answer 2

গণিত, 43 বাইট

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

এটি অনলাইন চেষ্টা করুন! (গণিত ব্যবহার করে।)

বিকল্পভাবে:

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

Comments

কোন বিল্ট ইন আছে?

— ম্যাজিক অক্টোপাস উর্ন

কি GatherByএকটি বিকল্প নিশ্চিত না, কারণ আমি ভাষা জানি না।

— ম্যাজিক অক্টোপাস উরন

@ কারাসোকম্পিউটিং এটি মূল তালিকার উপাদানগুলির প্রথম ঘটনা অনুসারে গোষ্ঠীগুলি সাজায় তাই আমার পরেও গ্রুপগুলি বাছাই করতে হবে। প্রথমে তালিকাটি বাছাই করার মাধ্যমে, আমি একটি বাইট সংরক্ষণ করতে পারি SplitBy(এছাড়াও SortByযদি আমি GatherByপ্রথমে করি তবে আসলে আরও জটিল হবে )।

— মার্টিন ইন্ডার

আকর্ষণীয়, সুতরাং "সর্বাধিক থেকে ন্যূনতম হতে হবে" কি এইগুলি মিস?

— ম্যাজিক অক্টোপাস উরন

পুনঃটুইট

— মার্টিন ইন্ডার

Answer 3

পাইথন 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))]

এটি অনলাইন চেষ্টা করুন!

কয়েক বছর পড়ার পরে এটি আমার প্রথম জমা।

এটি মূলত এটি সমস্ত উপাদানকে কাউন্টারে রাখে ( তালিকার প্রতিটি উপাদানগুলির কতটি অভিধান) এবং। Most_common () আইটেমগুলিকে প্রতারণামূলক ক্রমের মধ্যে রাখে। এর পরে, আইটেমগুলি সঠিক তালিকায় ফর্ম্যাট করার বিষয়টি কেবল।

Ovs ধন্যবাদ 4 বাইট সংরক্ষণ করা ।

Comments

পিপিসি :) তে আপনাকে স্বাগতম। আমার মতো আসক্ত হয়ে উঠবেন না।

— ম্যাজিক অক্টোপাস আরন

আপনার নিজস্ব আইটেমটার ফাংশন তৈরি করা এটি আমদানি করার চেয়ে 4 বাইট কম:o=lambda n:lambda l:l[n]

— ovs

Answer 4

জাভাস্ক্রিপ্ট (ES6), 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)

কিভাবে?

জন্য প্রতিটি উপাদান এক্স ইনপুট অ্যারের একটি , আমরা সংখ্যা গণনা এন উপাদানের একটি যে থেকে ভিন্ন এক্স :

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

আমরা সূচকের ব্যবহার এন এবং এক্স অ্যারের ভরাট ণ :

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

সম্পাদনা : যেহেতু জেএস নেতিবাচক অ্যারে সূচকগুলি সমর্থন করে না, তাই x * x + (x > 0)ইতিবাচক সূচকগুলিকে বাধ্য করার জন্য আমাদের সূত্রের প্রয়োজন ।

এটি আমাদের মূল তালিকার অনন্য উপাদান সম্বলিত অ্যারেগুলির একটি অ্যারে দেয়, ফ্রিকোয়েন্সি অনুসারে গোষ্ঠীভূত হয় এবং সর্বাধিক ঘন ঘন থেকে অন্তত ঘন ঘন ঘন অর্ডার হয়।

তবে বাইরের অ্যারে এবং অভ্যন্তরীণ অ্যারে উভয়েরই অনেকগুলি খালি স্লট রয়েছে যা আমরা ফিল্টার করতে চাই। আমরা ফাংশন সঙ্গে এই কাজ এফ , এর প্রয়োগ ণ এবং তার উপাদানের প্রতিটি:

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([]))) // []

Comments

আমি মনে করি 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]যে একটি অ্যারে থেকে একটি সেটে পরিবর্তন করাটা আলাদা ছিল তবে আমি ইতিমধ্যে @ রিকহিচককের উত্তরটি গল্ফ করেছিলাম সুতরাং এতটা পয়েন্ট নেই।

— নিল

Answer 5

পিএইচপি , 85 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 6

জেলি , 9 8 বাইট

QɓċЀĠṚị

এটি অনলাইন চেষ্টা করুন!

Comments

... পাইথ ... মারল ... জেলি?

— লিকি নুন

জেলির গ্রুপ-বাই নেই, যাতে অবাক হওয়ার কিছু নেই।

— ডেনিস

Answer 7

Clojure, 74 বাইট

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

বেশ ভার্জোজ দেখাচ্ছে: /

Comments

আমাকে এর কাছে মারুন (এবং কয়েকটা বাইট দিয়ে আমাকে মারধর করুন, comp -বিপরীত করার চতুর ব্যবহার !)। অন্যান্য ভাষার মতো সংক্ষিপ্ত নয়, তবে আমি ভেবেছিলাম যে এটি ক্লোজারের "গ্রুপ-বাই" এবং "ফ্রিকোয়েন্সি" অন্তর্নিহিত হয়েছে বলে মজাদার ছিল

— ম্যাটপুতনম

আমি যখন টাস্কের বিবরণটি পড়ি তখন আমি 50 বা 60 বাইটের আশায় ছিলাম, তবে প্রকৃত বাস্তবায়নটি কিছুটা জটিল হয়ে উঠল।

— নিকোনিহার

Answer 8

পার্ল 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])

Comments

বাহ, আমি সবসময় ভুলে যাই Bag, একটি সুন্দর!

— ম্যাজিক অক্টোপাস উরন

Answer 9

বাশ + জিএনইউ ইউটিলিটিস, 71 61

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

একটি নতুন লাইন-সীমাবদ্ধ তালিকা হিসাবে ইনপুট। কমা-বিভাজিত মানগুলির একটি নতুন লাইন-সীমিত তালিকা হিসাবে আউটপুট।

এটি অনলাইনে চেষ্টা করুন ।

Answer 10

এমএটিএল , 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

Answer 11

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

Comments

github.com/JohnEarnest/ok অন্য কারও জন্য কী ভেবে অবাক kহয়, এটি আসলে ok। বা-দম-tssss ...

— যাদু অক্টোপাস

Answer 12

ব্র্যাচল্যাগ , 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

Answer 13

গণিত, 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, 9, 5, 6, 5, 6, 5, 6, 5, 6, -56}]

আউটপুট

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

Comments

গ্যাটারবাই আমি মার্টিনকে উল্লেখ করেছি! আমি ভাবলাম কীভাবে এটি করা হবে :)।

— ম্যাজিক অক্টোপাস উরন

Sort[...,...&]ঠিক হয় SortBy[...,-Last@#&]।

— মার্টিন ইন্ডার

Length[f=...]। এবং First/@হয় #&@@@।

— মার্টিন ইন্ডার

স্থির, স্থির এবং স্থির

— J42161217

Answer 14

আর , 84 77 বাইট

-7 বাইট mb7744 ধন্যবাদ

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

স্টিডিন থেকে পড়া; ক্রমবর্ধমান ক্রমে পূর্ণসংখ্যার সাবভেেক্টরগুলির সাথে একটি তালিকা প্রদান করে। যদি আমরা ইনসগুলির পরিবর্তে স্ট্রিংগুলি ফিরে আসতে পারি, তবে আমি 11 বাইট (কলটি সরিয়ে ফেলতে as.double) ফেলতে পারি তবে এটি প্রায়। আর এর tableফাংশনটি এখানে ভারী উত্তোলন করে, এর ইনপুটটির প্রতিটি সদস্যের উপস্থিতি গণনা করে; তারপরে এটি তাদের গণনা অনুসারে একত্রিত করে ( names)। অবশ্যই এটি একটি স্ট্রিং, তাই আমাদের এটি বাধ্যতামূলক করতে হবে একটি পূর্ণসংখ্যা / ডাবল to

এটি অনলাইন চেষ্টা করুন!

Comments

"কোনটি" মুছে ফেলে এবং লজিক্যাল ইনডেক্সিং ব্যবহার করে আপনি 7 বাইট হারাতে পারেন

— mb7744

@ এমবি 7744 ওহ দুহ

— জিউসেপ

আর এর সাথে আমি এটিতে আরও একটি ছুরিকাঘাত করি। ল্যাম্বডা সিনট্যাক্সটি কত দীর্ঘ তা দুর্ভাগ্যজনক, তাই আমি এড়াতে চেষ্টা শুরু করি। বিনিময়ে আমাকে নেস্টেড ব্যবহার করতে হয়েছিল lapplyতবে কমপক্ষে সেই ক্ষেত্রে আমি একটি সংক্ষিপ্ত পরিবর্তনশীল নির্ধারণ করতে পারি lapply। আমি এই function

— ফাংশনটিতে

Answer 15

জাভাস্ক্রিপ্ট (ES6), 100 98 96 93 বাইট

@ নীলকে ধন্যবাদ দিয়ে 2 বাইট সংরক্ষণ করা হয়েছে (প্লাস তিনি আমার কোডটিতে একটি এজ-কেস বাগটি ঠিক করেছেন)। টমাসল্যাংকাআসকে আরও 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([])))

Comments

আপনার পরীক্ষার ত্রুটিপূর্ণ হয় (শূন্য হয়ে কাজ করে না) কিন্তু আমি ফিল্টারিং এবং unshifting পরিবর্তে reversing দ্বারা বাইট সংরক্ষণ এখনও মনে করি আপনি যা করতে পারেন: 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)।

— টমাস ল্যাংকাআস

ভালো লাগল, @ টমাস ল্যাংকাআস, ধন্যবাদ। (2 বাইট সংরক্ষণ করে))

— রিক হিচকক

আমার খারাপ (গণনা করতে সমস্যা আছে), তবে .filter(a=>a+a)অতিরিক্ত বাইট সরবরাহ করবে।

— টমাস ল্যাংকাআস

Answer 16

ভি , 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

আমি ভিটিকে যতটা ভালবাসি, আমি নিশ্চিত যে এটি কার্যের পক্ষে সবচেয়ে খারাপ ভাষা। বিশেষত বিবেচনা করে এটির তালিকাগুলির কোনও সমর্থন নেই এবং মূলত সংখ্যার পক্ষে কোনও সমর্থন নেই। কেবল স্ট্রিং ম্যানিপুলেশন।

Answer 17

সি #, 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()

Comments

+1 আপনি যদিও System.Func<int[],int[][]>F=এবং পিছনটি সরাতে পারেন ;। এটি এই ধরণের ল্যাম্বডাসের বাইট-কাউন্টের অংশ নয়।

— কেভিন ক্রুইসসেন

@ কেভিন ক্রুজসেন, আমার কোনও ধারণা ছিল না। ধন্যবাদ!

— হ্যান্ড-ই-ফুড

Answer 18

আর , 66 বাইট

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

এটি অনলাইন চেষ্টা করুন!

যদি আউটপুটে পূর্ণসংখ্যার স্ট্রিং ফর্ম্যাটে হতে পারে তবে 48 বাইটে নেমে যেতে পারে (@ জিউস্পির উত্তরে উল্লিখিত)।

---

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

Comments

as.doubleএক বাইট দ্বারা সংক্ষিপ্ত, এবং এটি হিসাবে কাজ করা উচিতas.integer

— জিউসেপ

ঠিক আছে, এটি নির্ভর করে যে আপনি কোনও পূর্ণসংখ্যা ফেরত দিতে চান বা ডাবল। যদি ডাবল ঠিক থাকে, তবে চরিত্রটিও হতে পারে এবং আমরা উভয় কিছু বাইট সংরক্ষণ করতে পারি।

— mb7744

Answer 19

পাওয়ারশেল, 77, 70 বাইট

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

নোট: এই ফলাফলগুলি সঠিকভাবে দলবদ্ধ হয়েছে তা দেখার জন্য (যেহেতু প্রতিটি অ্যারের সামগ্রীর মধ্যে দৃষ্টিভঙ্গি নেই), আপনি | write-hostউপরের লাইনের শেষে যুক্ত হতে পারেন to

প্রাপ্তি স্বীকার

ধন্যবাদ:

• TessellatingHeckler ব্যাপক refactoring / একটি পথ আরো golfed পদ্ধতির rewriting 7 বাইট সংরক্ষণ করার জন্য।

---

আগে

77 বাইট

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

Comments

সুন্দর ধন্যবাদ. আমাকে গ্রুপিংয়ের জন্য অন্তর্ভুক্ত করতে ,()হয়েছিল (যেহেতু আউটপুট কেবল একটি ধারাবাহিক অ্যারে হিসাবে দেখানো হয়েছিল)। এটি আমার আসল প্রয়াসের চেয়ে আরও গোলাপী; দুর্দান্ত কাজ!

— এলবেভান

Answer 20

গ্রোভি, 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]]
}

Answer 21

রুবি , 62 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এটি করার একটি ছোট উপায় হতে পারে।