चुनौती

एन पूर्णांकों के दिए गए सेट के लिए, एक प्रोग्राम लिखें जो इसके लेक्सोग्राफिक इंडेक्स को आउटपुट करेगा।

नियम

इनपुट केवल रिक्त स्थानों द्वारा अलग किए गए अद्वितीय गैर-नकारात्मक पूर्णांक का एक सेट होना चाहिए।
आपको क्रमपरिवर्तन के लेक्सोग्राफिक इंडेक्स (रेंज 0 से एन -1 समावेशी) का उत्पादन करना चाहिए।
कोई क्रमपरिवर्तन पुस्तकालयों या क्रमपरिवर्तन अंतर्निर्मित का उपयोग नहीं किया जा सकता है।
आप अनुक्रमणिका खोजने में मदद करने के लिए क्रमपरिवर्तन के सेट या इनपुट के क्रमपरिवर्तन के किसी भी सबसेट को उत्पन्न नहीं कर सकते हैं।
आप अगले / पिछले (lexicographically) क्रमचय के लिए दिए गए क्रमांकन को बढ़ा या घटा भी नहीं सकते।
बोनस अंक (-10 बाइट्स) यदि आपको फैक्टरियल का उपयोग किए बिना इसे पूरा करने का कोई रास्ता मिल जाए।
एन = 100 के लिए रनटाइम 1 मिनट से कम होना चाहिए
बाइट गिनती जीत से सबसे छोटा कोड
विजेता को मंगलवार (22 जुलाई, 2014) को चुना गया।

क्रमपरिवर्तन के बारे में अधिक जानकारी

उदाहरण

0 1 2 --> 0
0 2 1 --> 1
1 0 2 --> 2
1 2 0 --> 3
2 0 1 --> 4
2 1 0 --> 5
0 1 2 3 4 5 6 7 --> 0
0 1 2 3 4 5 7 6 --> 1
0 1 2 3 4 6 5 7 --> 2
1 3 5 17        --> 0
781 780 779 13  --> 23
81 62 19 12 11 8 2 0 --> 40319
195 124 719 1 51 6 3 --> 4181

— काइल मैककॉर्मिक
स्रोत

1

क्या हमारे पास विजेता चुने जाने तक अधिक समय हो सकता है? तीन दिन बहुत कम समय है।

— xnor

4

GolfScript, 12 (22 अक्षर - 10 बोनस)

~]0\.,{.,@*\.(@$?@+\}*

फैक्टरियल का उपयोग नहीं करने के लिए बोनस अंक। प्रश्न में निरस्त प्रारूप में STDIN पर इनपुट दिया जाना चाहिए। आप कोड को ऑनलाइन आज़मा सकते हैं ।

— हावर्ड
स्रोत

जब मैं "तथ्यात्मकता का उपयोग किए बिना" कह रहा था, तो मुझे वह नहीं मिल रहा था, लेकिन मुझे लगता है कि यह मायने रखता है। कुडोस

— काइल मैककॉर्मिक

4

सीजेएम, 31, गुटबाजी के साथ

q~]{__(f<0+:+\,,(;1+:**\(;}h]:+

— jimmy23013
स्रोत

मैं अभी भी क्यों उठ रहा हूँ? गोल्फस्क्रिप्ट उत्तर को केवल 23 पात्रों के साथ सीजेएम में फिर से लिखा जा सकता है।

— jimmy23013

6

क्योंकि लोगों को आपका जवाब पसंद है।

— seequ

1

अजगर 2 (77 = 87-10)

p=map(int,raw_input().split())
s=0
while p:s=s*len(p)+sorted(p).index(p.pop(0))
print s

ऐसा पठनीय। बहुत में निर्मित। वाह।

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

इसके बाद सरणी सूचकांकों पर लूपिंग करके, हम बार-बार सूची के पहले तत्व को हटाते हैं और शेष तत्वों को संसाधित करते हैं। एक्सप्रेशन sorted(p).index(p.pop(0))को सॉर्ट की गई सूची में अपना स्थान लेते हुए, पहले इंडेक्स के पिछले व्युत्क्रम की संख्या को गिना जाता है, जबकि एक ही समय में निष्कासन करते हैं।

अफसोस की बात है, मुझे पायथन 2 का उपयोग करना पड़ा और raw_input(हालांकि -1 के लिए print) 4 और पात्रों को लेना पड़ा क्योंकि पायथन 3 में map(int,...)एक मैप ऑब्जेक्ट का उत्पादन होता है, जो सूची संचालन का समर्थन नहीं करता है,

— XNOR
स्रोत

1

पायथ (13 = 23-10)

JVPwdWJ=Z+*ZlJXovNJ;J)Z

मेरे पायथन जवाब का एक बंदरगाह ।

एक पायथन अनुवाद (कुछ अप्रासंगिक सामानों को छान कर निकाला गया):

Z=0
J=rev(split(input()," "))
while J:
 Z=plus(times(Z,len(J)),index(order(lambda N:eval(N),J),J.pop()))
print(Z)

इनपुट नंबर स्ट्रिंग्स रहते हैं, लेकिन कुंजी के रूप में eval का उपयोग करके इन्टस के रूप में सॉर्ट किए जाते हैं। सूची को उल्टा कर दिया जाता है ताकि popपीछे के बजाय सामने की तरफ ले जाए ।

— XNOR
स्रोत

1

कोबरा - 202

जाहिर है कोबरा वास्तव में इस में प्रतिस्पर्धा नहीं कर रहा है।

class P
    var n=0
    var t=CobraCore.commandLineArgs[1:]
    def main
        .f(.t[0:0])
    def f(l as List<of String>)
        if.t.count==l.count,print if(.t<>l,'',.n+=1)
        else,for i in.t.sorted,if i not in l,.f(l+[i])

— Οurous
स्रोत

0

जे, 5 बाइट्स (15 - 10)

#\.#.+/@(<{.)\.

यह O ( n ² ) समय में चलता है और आसानी से n = 100 को संभालने में सक्षम है ।

प्रयोग

   f =: #\.#.+/@(<{.)\.
   f 0 1 2
0
   f 0 2 1
1
   f 1 0 2
2
   f 1 2 0
3
   f 2 0 1
4
   f 2 1 0
5
   f 0 1 2 3 4 5 6 7
0
   f 0 1 2 3 4 5 7 6
1
   f 0 1 2 3 4 6 5 7
2
   f 1 3 5 17
0
   f 781 780 779 13
23
   f 81 62 19 12 11 8 2 0
40319
   f 195 124 719 1 51 6 3
4181
   NB. A. is the builtin for permutation indexing
   timex 'r =: f 927 A. i. 100'
0.000161
   r
927

व्याख्या

#\.#.+/@(<{.)\.  Input: array P
             \.  For each suffix of P
          {.       Take the head
         <         Test if it is greater than each of that suffix
     +/@           Sum, count the number of times it is greater
#\.              Get the length of each suffix of P
   #.            Convert to decimal using a mixed radix

— मील की दूरी पर
स्रोत

क्रमपरिवर्तन संख्या