अज्ञात आधार में क्रमबद्ध संख्याएँ

Question

तार की एक सूची को देखते हुए, सूची को बिना आधार के उपयोग किए गए संख्याओं के अनुसार क्रमबद्ध करें। अंकों के मूल्य भी अज्ञात हैं (यह संभव है कि '1'> '2')।

चूंकि अंकों के मूल्य अज्ञात हैं, इसलिए अंकों के सापेक्ष मूल्य को निर्धारित करने के लिए बेनफोर्ड के नियम (या पहले अंक के कानून) का उपयोग करें। बेनफोर्ड के नियम का पालन करने वाले वितरणों के लिए, कम मूल्यवान अंक एक अग्रणी अंक के रूप में अधिक मूल्यवान अंकों की तुलना में अधिक बार दिखाई देते हैं।

नियम

• यह कोड-गोल्फ है
• तार की सूची आपके चुनने के स्रोत (स्टड, चर, फ़ाइल, उपयोगकर्ता, आदि) से आ सकती है।
• तार ASCII वर्णों तक सीमित हैं।
• एक प्रमुख चरित्र के रूप में प्रकट नहीं होने वाले वर्णों में उच्चतम मूल्य होते हैं। (मान लें कि कोई शून्य नहीं है, और प्रमुख आवृत्ति द्वारा सख्ती से सॉर्ट करें।)
• वर्ण जो प्रमुख अंकों के रूप में दिखाई देते हैं, वे उतने ही बार होते हैं जितने अन्य वर्ण समान रूप से भारित होते हैं।

उदाहरण

अवर्गीकृत

['c','ca','ac','cc','a','ccc','cx','cz','cy']

क्रमबद्ध

['c','a','cc','ca','cz','cy','cx','ac','ccc']

नोट: उदाहरण में 'cz', 'cy'और 'cx'अंकों के बाद से किसी भी क्रम में 5 वें, 6 वें और 7 वें तत्वों के रूप में प्रकट हो सकते हैं 'x', 'y'और 'z'समान रूप से भारित होते हैं।

Comments

"तार ASCII वर्णों तक सीमित हैं।" आपका उदाहरण केवल अल्फ़ान्यूमेरिक्स (वास्तव में केवल वर्णमाला वर्ण) दिखाता है। क्या आप सभी ASCII वर्ण या सिर्फ [0-9a-zA-Z] से मतलब रखते हैं, और निचले मामले के अक्षर समान या अलग-अलग ऊपरी अक्षरों से गिनते हैं?

— यहोशू टेलर

सभी ASCII वर्णों का समर्थन किया जाना चाहिए, और अपरकेस और लोअरकेस अलग हैं।

— रिनेंट

Answer 1

अजगर, 59 108 112

sorted(a,None,lambda x:(-len(x),map(zip(*a)[0].count,x)),1)

इनपुट को सूची के रूप में प्रदान किया गया है a, और यह अभिव्यक्ति क्रमबद्ध सूची (एक चर पर असाइन करने के लिए +2 वर्ण) का उत्पादन करती है। यह सूची को नकारात्मक लंबाई और फिर आवृत्ति द्वारा उल्टा करता है।

Comments

+1 किया। नहीं सोचा था कि यह एकल अभिव्यक्ति में कुशलता से जगह बना सकता है।

— देखिए

अच्छा! मैं के बारे में पता नहीं था zipके साथ None। हालांकि यह पायथन 3 में काम नहीं करता है जो इसका उपयोग करेगा itertools.zip_longest।

— रिनेंट

Noneअजगर 3 में पूर्णांक की तुलना नहीं कर सकते हैं, इसलिए यह वैसे भी विफल होगा।

— nnonneo

@nneonneo राइट, fillvalueको सबसे छोटे मूल्य से कुछ कम पर सेट करना होगा।

— रिनेंट

और मुझे लगा कि मुझे अजगर के बारे में कुछ पता है - नहीं। क्या आप अपने कोड को कुछ और विस्तृत बता सकते हैं? मैं बहुत खुश हूँ - अजगर नौसिखिया यहाँ।

— त्रुटी

Answer 2

रूबी, ६५

f=->a{a.sort_by{|s|[s.size,s.chars.map{|c|a.count{|t|t[0]!=c}}]}}

स्ट्रिंग के आकार पर लेक्सोग्राफिक रूप से सॉर्ट करता है, फिर प्रत्येक वर्ण की आवृत्ति के रूप में अग्रणी अंक नहीं।

Answer 3

जावा (261)

void s(String[]s){int[]a=new int[128];for(String t:s)a[t.charAt(0)]++;java.util.Arrays.sort(s,(o,p)->{int j=o.length()-p.length();if(j!=0)return j;for(int i=0;i<Math.min(o.length(),p.length());i++){j=a[p.charAt(i)]-a[o.charAt(i)];if(j!=0)return j;}return 0;});}

void s(String[] s) {
    int[] a = new int[128];
    for (String t : s) {
        a[t.charAt(0)]++;
    }
    java.util.Arrays.sort(s, (o, p) -> {
        int j = o.length() - p.length();
        if (j != 0) {
            return j;
        }
        for (int i = 0; i < Math.min(o.length(), p.length()); i++) {
            j = a[p.charAt(i)] - a[o.charAt(i)];
            if (j != 0) {
                return j;
            }
        }
        return 0;
    });
}

विधियाँ स्ट्रिंग की एक सरणी लेती हैं, और जगह में सरणी को सॉर्ट करती हैं। कार्यान्वयन के बारे में कुछ भी कल्पना नहीं है, लेकिन यह जावा 8 में जोड़े गए लैम्ब्डा अभिव्यक्तियों का उपयोग करता है।

Answer 4

जावास्क्रिप्ट (E6) 147

F=i=>(f={},i.map(x=>(f[x[0]]=-~f[x[0]])),i.map(x=>[x,[...x].map(y=>1e9-~f[y]+'')]).sort((a,b,d=a[0].length-b[0].length)=>d||a[1]<b[1]).map(x=>x[0]))

सीमा

आवृत्ति मान 1000000000 तक: छँटाई के लिए, आवृत्ति मान एक बड़े गद्देदार स्ट्रिंग में विलय कर दिए जाते हैं

Ungolfed

F=i=>(
  f={}, //init frequency map
  i.map(x => (f[x[0]]=-~f[x[0]])), // build frequency map
  i.map(x => [x, [...x].map(y=>1e9-~f[y]+'')]) // add frequency info to each element of input list
 .sort((a,b,d=a[0].length-b[0].length)=>d || a[1]<b[1]) // then sort by lenght and frequency
 .map( x => x[0]) // throw away frequency info
)

X-~मूल संख्या X अपरिभाषित या NaN होने पर भी 1 से सिडेनोट वृद्धि

प्रयोग

F(['c','ca','ac','cc','a','ccc','cx','cz','cy'])

आउटपुट: ["c", "a", "cc", "ca", "cx", "cz", "cy", "ac", "ccc"]