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

Question

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

उदाहरण:

दिया हुआ:

["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]

अपेक्षित वापसी मूल्य:

["Doe","Harry","John","Dick"]

Comments

कोड-गोल्फ या कोड-चैलेंज?

— मारिनस

कोड-गोल्फ। वह गलती थी। इसे ठीक करें

— बेल

Answer 1

एपीएल (14)

{∪⍵[⍒+⌿∘.≡⍨⍵]}

यह एक फ़ंक्शन है जो एक सूची लेता है, जैसे:

      names
 John  Doe  Dick  Harry  Harry  Doe  Doe  Harry  Doe  John 
      {∪⍵[⍒+⌿∘.≡⍨⍵]} names
 Doe  Harry  John  Dick

स्पष्टीकरण:

• ∘.≡⍨⍵: ऐरे में प्रत्येक एलीमेंट की तुलना ऐरे में एक दूसरे एलीमेंट से करें
• +⌿: मैट्रिक्स के स्तंभों को योग दें, प्रत्येक तत्व कितनी बार होता है
• ⍒: नीचे की तरह के सूचकांक दे
• ⍵[... ]: ⍵दिए गए सूचकांकों द्वारा पुन: व्यवस्थित किया गया
• ∪: अद्वितीय तत्व प्राप्त करें

Comments

और फिर भी किसी तरह वे इस संक्षिप्त मजाकिया भाषा से जावा "प्रगति" के लिए जा रहे हैं? (-:

— हिप्पिट्रैएल

Answer 2

पायथन 3 - 47 43; अजगर 2 - 40 39

पायथन 3 के लिए:

f=lambda n:sorted(set(n),key=n.count)[::-1]

पायथन 2 के लिए:

f=lambda n:sorted(set(n),cmp,n.count,1)

डेमो:

>>> names = ["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]
>>> f(names)
['Doe', 'Harry', 'John', 'Dick']

Comments

मैं वही पोस्ट करने की कोशिश कर रहा था, लेकिन यहाँ एक संशोधन है। f=lambda n:sorted(set(n),cmp,n.count,1)39 अक्षर

— आप

हम्म, मुझे नहीं पता था कि आप एक गैर- cmpफ़ंक्शन और फ़ंक्शन दोनों पास कर सकते हैं key। ठंडा।

— ब्लाकनाथ

थोड़ा छोटा:f=lambda n:sorted(set(n),key=n.count)[::-1]

— grc

धन्यवाद @grc, विदेशी स्माइली पायथन 3 मामले में कुछ पात्रों को बचाती है।

— 21

Answer 3

गणितज्ञ, ३१

Sort[GatherBy@n][[-1;;1;;-1,1]]

{"Doe", "Harry", "John", "Dick"}

(के साथ n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"})

Comments

डारन, तुम मुझे वहां ले आए: D

— Yves Klett

@YvesKlett धन्यवाद मैं छुटकारा पाने के बारे में सोच रहा हूं Reverse, लेकिन Sort[GatherBy@n][[-1;;1, 1]]काम नहीं करता है :)। कोई विचार?

— अज्जाजा

आह, यह समझ में आ गया। mathematica.stackexchange.com/a/22320/745

— Ajasja

Answer 4

गणितज्ञ (२६) 37)

के साथ n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"}:

Last/@Gather@n~SortBy~Length//Reverse

{"डो", "हैरी", "जॉन", "डिक"}

---

गणितज्ञ V10 + (26) :

Keys@Sort[Counts[n],#>#2&]

Comments

@garej उपयोग में पुराना संस्करण। किसी अन्य उत्तर के रूप में पोस्ट करें?

— यव्स केलेट

अगर आप बुरा न मानें तो मैंने आपके साथ जोड़ा ...

— garej

@garej। धन्यवाद, उत्कृष्ट समाधान!

— यव्स केलेट

Answer 5

पर्ल 6 (36 बाइट्स, 35 अक्षर)

»के साथ प्रतिस्थापित किया जा सकता है >>, यदि आप UTF-8 को संभाल नहीं सकते हैं। मुझे लगभग यकीन है कि यह छोटा हो सकता है, लेकिन Bagवर्ग अपने व्यवहार (दुख की बात) में अपेक्षाकृत अजीब है, और वास्तव में पूर्ण नहीं है, क्योंकि यह अपेक्षाकृत नया है (लेकिन यह तर्क गिना सकता है)। {}एक अनाम फ़ंक्शन घोषित करता है।

{(sort -*.value,pairs bag @_)».key}

नमूना उत्पादन (पर्ल 6 आरईपीएल से):

> my @names = ("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")
John Doe Dick Harry Harry Doe Doe Harry Doe John
> {(sort -*.value,pairs bag @_)».key}(@names)
Doe Harry John Dick

Answer 6

रूबी: 34 37 पात्र

f=->a{a.sort_by{|z|-a.count(z)}&a}

(संपादित: पिछले 30-चार समाधान समारोह का शरीर था)

Comments

आप कुछ पात्रों को ट्रिम कर सकते हैं f=->a{a.sort_by{|z|-a.count(z)}&a}। &एक uniq करता है।

— हिस्टोक्रेट

Answer 7

GolfScript, 14 वर्ण (नाम के रूप में 19 समारोह, पूर्ण कार्यक्रम के रूप में भी 14)

:a.|{[.]a\-,}$

यह कोड ढेर पर एक सरणी लेता है और घटित क्रम से घटते क्रम में अपने अद्वितीय तत्वों को सॉर्ट करता है। उदाहरण के लिए, यदि इनपुट ऐरे है:

["John" "Doe" "Dick" "Harry" "Harry" "Doe" "Doe" "Harry" "Doe" "John"]

तब आउटपुट ऐरे होगा

["Doe" "Harry" "John" "Dick"]

नोट: ऊपर दिया गया कोड बयानों का एक नंगे अनुक्रम है। इसे एक नामित फ़ंक्शन में बदलने के लिए, इसे ब्रेसिज़ में लपेटें और इसे एक नाम के रूप में असाइन करें:

{:a.|{[.]a\-,}$}:f;

वैकल्पिक रूप से, कोड को एक पूर्ण कार्यक्रम में बदलने के लिए जो मानक इनपुट से एक सूची पढ़ता है (ऊपर दिखाए गए सूची संकेतन का उपयोग करके) और इसे मानक आउटपुट, प्रीपेन्ड ~और एपेंड में प्रिंट करता है।` कोड को करता है। [. इस मामले में छोड़ा जा सकता है (क्योंकि हम जानते हैं कि ढेर पर और कुछ नहीं होगा), इसलिए कि जिसके परिणामस्वरूप 14-चरित्र कार्यक्रम होगा:

~:a.|{]a\-,}$`

---

यह कैसे काम करता है?

• :aaबाद में उपयोग के लिए चर में मूल सरणी की एक प्रति बचाता है ।

• .| एक साइड इफेक्ट के रूप में डुप्लिकेट को समाप्त करते हुए, सरणी के सेट यूनियन को खुद के साथ गणना करता है।

• { }$ब्रेसिज़ के अंदर कोड द्वारा गणना की गई कस्टम सॉर्ट कुंजी का उपयोग करके डी-डुप्लिकेट की गई सरणी को सॉर्ट करें। यह कोड प्रत्येक सरणी तत्व लेता है, इसे सहेजे गए मूल इनपुट सरणी से हटाने के लिए सरणी घटाव का उपयोग करता हैa , और शेष तत्वों की संख्या की गणना करता है। इस प्रकार, तत्व आवृत्ति के घटते क्रम में क्रमबद्ध हो जाते हैं।

Ps। मूल 30-वर्ण संस्करण के लिए यहां देखें ।

Comments

मुझे लगता है कि [a\])^इसके बराबर होना चाहिए [.;]a\-। गैर-मिलान तत्वों की संख्या के आधार पर छाँटना एक अच्छा विचार है।

— पीटर टेलर

काश, नहीं: ^डुप्लिकेट को ध्वस्त -करता है , नहीं। (और ITYM (, नहीं )।) [a\](\-काम करेगा, लेकिन किसी भी चरित्र को नहीं बचाएगा।

— इल्मरी करोनें

Answer 8

आर: 23 अक्षर

n <- c("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")

names(sort(table(n),T))
## [1] "Doe"   "Harry" "John"  "Dick" 

लेकिन यह इतना अच्छा शॉर्टकट का उपयोग नहीं करता Tहै TRUE...

Answer 9

अगर यह यहाँ फिट हो सकता है: In sql-server

create table #t1 (name varchar(10))
insert into #t1 values ('John'),('Doe'),('Dick'),('Harry'),('Harry'),('Doe'),('Doe'),('Harry'),('Doe'),('John')


select name from #t1 group by name order by count(*) desc

या

with cte as
(

select name,count(name) as x from #t1 group by name
)

select name from cte order by x desc

इसे कार्रवाई में देखें

Comments

CTE क्यों? select name from #t1 group by name order by count(*) desc

— manatwork

Answer 10

PHP, 63 62 61 वर्ण

function R($a){foreach($a as$v)$b[$v]++;arsort($b);return$b;}

डेमो:

$c = array("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John");
$d = print_r(R($c));

Array ( [Doe] => 4 [Harry] => 3 [John] => 2 [Dick] => 1 )

Comments

पर एक नज़र है array_count_values()... यह आपको (सहित arsort()) का उपयोग करना है

— bwoebi

array_count_values()जैसा कि मैं देख सकता हूं, न ही डुप्लिकेट मानों को हटाता है, न ही उन्हें ऑर्डर करता है।

— वीरोस

यह डुप्लिकेट को हटाता है ... यह सिर्फ उन्हें आदेश नहीं देता है ... => arsort

— bwoebi

@bwoebi आप सही हैं। दुर्भाग्य से इसे इस तरह से लिखना इस उत्तर से 1 वर्ण अधिक लंबा है।

— टिम सेगिन

array_count_valuesलंबा रास्ता क्यों है ? <?$u=array_count_values($_GET);arsort($u);print_r($u);मेरी राय में 54 बाइट्स हैं

— Jörg Hülsermann

Answer 11

रूबी: 59 अक्षर

f=->n{n.group_by{|i|i}.sort_by{|i|-i[1].size}.map{|i|i[0]}}

नमूना रन:

irb(main):001:0> f=->n{n.group_by{|i|i}.sort_by{|i|-i[1].size}.map{|i|i[0]}}
=> #<Proc:0x93b2e10@(irb):2 (lambda)>

irb(main):004:0> f[["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]]
=> ["Doe", "Harry", "John", "Dick"]

Answer 12

गणितज्ञ, 39 वर्ण

f = Reverse[First /@ SortBy[Tally@#, Last]] &

names = {"John", "Doe", "Dick", "Harry", "Harry",
         "Doe", "Doe", "Harry", "Doe", "John"};

f@names

{डो, हैरी, जॉन, डिक}

Answer 13

जावास्क्रिप्ट (ECMAScript5): 118 113 अक्षर

function f(n){m={}
for(i in n){m[n[i]]=m[n[i]]+1||1}
return Object.keys(m).sort(function(a,b){return m[b]-m[a]})}

http://jsfiddle.net/mblase75/crg5B/

Comments

सद्भाव के साथ वसा तीर कार्यों : f=n=>{m={};n.forEach(e=>m[e]=m[e]+1||1);return Object.keys(m).sort((a,b)=>m[b]-m[a])}। (वर्तमान में केवल फ़ायरफ़ॉक्स में।)

— manatwork

आप m[n[i]]=-~m[n[i]]वेतन वृद्धि के लिए उपयोग कर सकते हैं , और आपको लूप बॉडी के आसपास {} की आवश्यकता नहीं है।

— नील

Answer 14

हास्केल - 53 वर्ण

import Data.List
import Data.Ord

f :: (Eq a, Ord a) => [a] -> [a]
f=map head.(sortBy$flip$comparing length).group.sort

स्पष्टीकरण: पहली दो लाइनें आवश्यक आयात हैं, कोड की अगली पंक्ति प्रकार का हस्ताक्षर (आमतौर पर आवश्यक नहीं) है, वास्तविक कार्य अंतिम पंक्ति है। फ़ंक्शन अपने प्राकृतिक क्रम से सूची को सॉर्ट करता है, सूची में समान तत्वों को समूह करता है, सूची के आकार को अवरोही आकार के आधार पर सॉर्ट करता है, और प्रत्येक सूची में पहला तत्व लेता है।

आयात सहित कुल लंबाई: 120

डब्ल्यू / ओ आयात लेकिन प्रकार के हस्ताक्षर के साथ: 86

समारोह ही: 53

Answer 15

क्लोजर: 43 अक्षर

समारोह:

#(keys(sort-by(comp - val)(frequencies %)))

डेमो (उत्तर में):

user=> (def names ["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"])
#'user/names
user=> (#(keys(sort-by(comp - val)(frequencies %))) names)
("Doe" "Harry" "John" "Dick")

Answer 16

पर्ल

दिए गए i / o कल्पना को पूरा करने के लिए मुझे 120 वर्णों की आवश्यकता है

s!"([^"]+)"[],]!$a{$1}++!e while(<>);print 'MostOccuring = [',join(',',map{qq("$_")}sort{$a{$a}<=>$a{$b}}keys %a),"]\n"

प्रति पंक्ति एक आइटम लेने और प्रति पंक्ति एक आइटम प्रिंट करने से शुद्ध सबसे छोटा कोड मुझे केवल 55 वर्णों की आवश्यकता है

$a{$_}++ while(<>);print sort{$a{$a}<=>$a{$b}}keys %a)

Answer 17

C #: 111 अक्षर

List<string>M(List<string>l){return l.GroupBy(q=>q).OrderByDescending(g=>g.Count()).Select(g=>g.Key).ToList();}

(एक वर्ग के अंदर)

var names = new List<string> {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"};
foreach(var s in M(names))
{
    Console.WriteLine(s);
}

हरिणी

सताना

जॉन

लिंग

LINQ का उपयोग करके एक सरल समाधान।

Comments

तुम भी निकाल सकते .ToList () , के बाद से अनुक्रम के माध्यम से प्रगणित हो foreach

— एडम स्पीट

यह सच है, लेकिन फिर मुझे रिटर्न टाइप को IEnumerable <string> में बदलना होगा ।

— पावोहट्ल

Answer 18

आर (22)

names(sort(-table(x)))

एक समारोह के रूप में यह 11 और वर्ण लेगा।

उपयोग:

> x = c("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")
> names(sort(-table(x)))
[1] "Doe"   "Harry" "John"  "Dick"

Comments

यह एक चर से इनपुट लेता है, जो समुदाय की सहमति से अस्वीकृत है ।

— फल

Answer 19

स्काला (71)

(x.groupBy(a=>a)map(t=>(t._1,t._2.length))toList)sortBy(-_._2)map(_._1)

Ungolfed:

def f(x:Array[String]) =
  (x.groupBy(a => a) map (t => (t._1, t._2.length)) toList) 
    sortBy(-_._2) map(_._1)

Answer 20

जे, 8 बाइट्स

~.\:#/.~

प्रयोग

नामों को बॉक्सिंग स्ट्रिंग्स की एक सरणी के रूप में संग्रहीत किया जाता है।

   'John';'Doe';'Dick';'Harry';'Harry';'Doe';'Doe';'Harry';'Doe';'John'
┌────┬───┬────┬─────┬─────┬───┬───┬─────┬───┬────┐
│John│Doe│Dick│Harry│Harry│Doe│Doe│Harry│Doe│John│
└────┴───┴────┴─────┴─────┴───┴───┴─────┴───┴────┘
   f =: ~.\:#/.~
   f 'John';'Doe';'Dick';'Harry';'Harry';'Doe';'Doe';'Harry';'Doe';'John'
┌───┬─────┬────┬────┐
│Doe│Harry│John│Dick│
└───┴─────┴────┴────┘

व्याख्या

~.\:#/.~   Input: A
    #/.~   Finds the size of each set of identical items (Frequencies)
~.         List the distinct values in A
           Note: the distinct values and frequencies will be in the same order
  \:       Sort the distinct values in decreasing order according to the frequencies
           Return the sorted list implicitly

Answer 21

सीजाम, 15 बाइट्स (संभवतः गैर-प्रतिस्पर्धात्मक)

q~$e`{0=W*}$1f=

इस चुनौती के पोस्ट होने के बाद से CJam सुविधाओं का उपयोग किया जा सकता है। मैं जांच के लिए बहुत आलसी हूं।