परिचय

N तत्वों के साथ एक सूची के लेक्सोग्राफिक क्रमपरिवर्तन को 0 से n तक गिना जा सकता है ! - 1. उदाहरण के लिए, 3! = 6 क्रमपरिवर्तन (1,2,3)होगा (1,2,3), (1,3,2), (2,1,3), (2,3,1),(3,1,2) , (3,2,1)।

जब किसी सूची में एक क्रमपरिवर्तन लागू किया जाता है, तो इसके तत्वों को क्रमबद्धता में संख्याओं के समान क्रम में आदेश दिया जाता है। उदाहरण के लिए, पैदावार (2,3,1)को l = (a,b,c)पैदावार पर लागू करना (l[2],l[3],l[1]) = (b,c,a)।

क्रमपरिवर्तन के व्युत्क्रम को इस ऑपरेशन को उलटने वाले क्रमपरिवर्तन के रूप में परिभाषित किया जाता है, अर्थात क्रमपरिवर्तन को लागू करना और फिर इसका उलटा (या इसके विपरीत) सरणी को संशोधित नहीं करता है। उदाहरण के लिए, प्रतिलोम (2,3,1)है (3,1,2), जो कि (b,c,a)पैदावार के लिए लागू होता है (a,b,c)।

इसके अलावा, क्रमपरिवर्तन के लिए लागू एक क्रमपरिवर्तन का व्युत्क्रम ही पूर्णांक 1 ... n पैदा करता है । उदाहरण के लिए, आवेदन (3,1,2)करना(2,3,1) पैदावार के(1,2,3) ।

अब हम फंक्शन रिवाइंड ( x ) को इंडेक्स x के साथ क्रमपरिवर्तन के व्युत्क्रम क्रमांक के रूप में परिभाषित करते हैं । (यह A056019 है यदि आप रुचि रखते हैं तो ।)

सूचकांक के साथ एक क्रमपरिवर्तन के बाद से मैं केवल पिछले संशोधित करता कश्मीर सूची के आइटम iff 0 ≤ मैं < कश्मीर !, हम सूची के शुरू करने के तत्वों के किसी भी संख्या को प्रभावित किए बिना जोड़ सकते हैं revind ( मैं )। इसलिए सूची की लंबाई परिणाम को प्रभावित नहीं करती है।

चुनौती

आपका काम रिवाइंड ( x ) लागू करना है । आप एक पूर्ण कार्यक्रम या फ़ंक्शन लिखेंगे जो एकल nonnegative पूर्णांक x लेता है को इनपुट / तर्क और आउटपुट / एकल nonnegative पूर्णांक के रूप में परिणाम देता है।

इनपुट और आउटपुट 0-अनुक्रमित या 1-अनुक्रमित हो सकते हैं, लेकिन यह उनके बीच सुसंगत होना चाहिए।

अनुक्रमणिका द्वारा क्रमपरिवर्तन उत्पन्न करने वाले बिल्डरों, क्रमपरिवर्तन के सूचकांक को वापस करते हैं या पाते हैं कि व्युत्क्रम क्रमपरिवर्तन पर प्रतिबंध है। (बिल्ट जो सभी क्रमपरिवर्तन उत्पन्न करते हैं या अगले क्रमपरिवर्तन की अनुमति है।)

मानक कोड-गोल्फ नियम लागू होते हैं।

उदाहरण

नीचे दिए गए उदाहरण 0-अनुक्रमित हैं।

Input    Output
0        0
1        1
2        2
3        4
4        3
5        5
6        6
13       10
42       51
100      41
1000     3628
2000     3974
10000    30593
100000   303016

संदर्भ कार्यान्वयन (पायथन 3)

def revind(n):
    from math import factorial
    from itertools import permutations, count
    l = next(filter(lambda x: factorial(x) > n, count(1)))
    pms = list(permutations(range(l)))
    return [k for k in range(len(pms)) if tuple(pms[n][i] for i in pms[k]) == pms[0]][0]

code-golf combinatorics permutations code-golf image-processing brainfuck encode steganography code-golf ascii-art code-golf ascii-art kolmogorov-complexity code-golf ascii-art fibonacci code-golf string code-golf sorting popularity-contest statistics code-golf ascii-art kolmogorov-complexity code-golf code-golf ascii-art tic-tac-toe code-golf string code-challenge classification test-battery binary-matrix code-golf math arithmetic code-golf ascii-art random code-golf string code-golf number binary bitwise code-golf number arithmetic code-golf math ascii-art code-golf string ascii-art code-golf string ascii-art code-golf string code-golf counting code-golf number binary bitwise decision-problem code-golf array-manipulation code-golf tips brain-flak code-challenge quine source-layout code-generation code-golf linear-algebra matrix abstract-algebra binary-matrix code-golf string palindrome code-golf puzzle-solver sudoku code-golf ascii-art code-golf graphical-output internet code-golf ascii-art kolmogorov-complexity code-golf math code-golf clock

— PurkkaKoodari
स्रोत

12

तितर बितर साजिश काफी मजेदार लग रहा है। :)

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

1

मुझे इस चुनौती को समझने के लिए उलटे क्रमपरिवर्तन की परिभाषा देखनी थी। मुझे आपका उदाहरण (a,b,c)बेहद अस्पष्ट है। एक व्युत्क्रम क्रमपरिवर्तन क्या है, इसकी उचित व्याख्या शामिल करें।

— 6

@ जानिए यह केवल समझाने के लिए कठिन है। अब बेहतर है?

— पुरकाकूदरी

जेली में परमाणु Ụ(ग्रेड अप) होता है जो एक सरणी के सूचकांकों को उनके संबंधित मूल्यों द्वारा क्रमबद्ध करता है। यह 1,…, n के क्रमपरिवर्तन को पलटने के लिए होता है , लेकिन यह अन्य क्रमपरिवर्तन के लिए काम नहीं करता है। है एक वर्जित निर्मित? Ụ

— डेनिस

@ डेनिस हार्ड सवाल। तकनीकी रूप से, यह किसी भी सख्ती से बढ़ती सूची पर लागू होने के बाद किसी भी क्रमपरिवर्तन का विलोम पाता है। इसलिए मैं कहने जा रहा हूँ कि अनुमति नहीं है। (अगर कोई सख्ती से असहमत, टिप्पणी के लिए स्वतंत्र महसूस मैं इतना इच्छाओं इस करता है, तो समुदाय बदल सकते हैं।।)

— PurkkaKoodari

5

जेली , 6 बाइट्स

ịŒ!⁺iR

I / O 1-आधारित अनुक्रमण का उपयोग करता है। बहुत धीमी और स्मृति-भूख।

सत्यापन

जब तक इनपुट 8 से अधिक न हो जाए ! = 40320 , यह सरणी के सभी क्रमपरिवर्तन [1,…, 8] पर विचार करने के लिए पर्याप्त है । अंतिम परीक्षण मामले के लिए, [1,…, 9] के क्रमपरिवर्तन पर्याप्त हैं।

थोड़े संशोधित कोड के साथ जो केवल पहले 8 या 9 पॉजिटिव पूर्णांक के क्रमपरिवर्तन पर विचार करता है , आप इसे ऑनलाइन आज़मा सकते हैं ! या सभी शेष परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ịŒ!⁺iR  Main link. Argument: n

 Œ!     Yield all permutations of [1, ..., n].
ị       At-index; retrieve the n-th permutation.
   ⁺    Duplicate the Œ! atom, generating all permutations of the n-th permutation.
     R  Range; yield [1, ..., n].
    i   Index; find the index of [1, ..., n] in the generated 2D array.

वैकल्पिक दृष्टिकोण, 6 बाइट्स (अमान्य)

Œ!Ụ€Ụi

यह लंबे समय के रूप में है और यह निषिद्ध ग्रेड परमाणु का उपयोग करता हैỤ , लेकिन यह (यकीनन) अधिक मुहावरेदार है।

Prepending द्वारा 8 (या 9 अंतिम परीक्षण मामले के लिए), हम वास्तव में कर सकते हैं यह ऑनलाइन कोशिश करो!

यह काम किस प्रकार करता है

Œ!Ụ€Ụi  Main link. Argument: n

Œ!      Yield all permutations of [1, ..., n].
  Ụ€    Grade up each; sort the indices of each permutation by the corresponding
        values. For a permutation of [1, ..., n], this inverts the permutation.
    Ụ   Grade up; sort [1, ..., n!] by the corresponding inverted permutations
        (lexicographical order).
     i  Index; yield the 1-based index of n, which corresponds to the inverse of
        the n-th permutation.

— डेनिस
स्रोत

6

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

Max@k[i,Flatten@Outer[i=Permutations[j=Range@#];k=Position,{i[[#]]},j,1]]&

1-अनुक्रमण का उपयोग करता है। बहुत अकुशल। (इनपुट होने पर ~ 11GB मेमोरी का उपयोग करता है11 )

व्याख्या

j=Range@#

1 से N. स्टोर में एक सूची बनाएं जो इसमें है j।

i=Permutations[...]

के सभी क्रमांक ज्ञात कीजिए j। इसमें स्टोर करें i।

k=Position

में Positionफंक्शन को स्टोर करें k। ( Positionफिर से उपयोग करते समय बाइट-काउंट को कम करने के लिए )

Flatten@Outer[...,{i[[#]]},j,1]

एन-वें क्रमपरिवर्तन का उलटा क्रमांक ज्ञात कीजिए।

Max@k[i,...]

में व्युत्क्रम क्रमचय का k( Position) ज्ञात कीजिएi (सभी क्रमपरिवर्तन)

बिल्ट-इन, 46 43 बाइट्स का उपयोग करना

a[(a=Ordering)/@Permutations@Range@#][[#]]&

1 अनुक्रमित।

— जंगहवान मिन
स्रोत

2

"बिलिंस कि ... उलटा क्रमपरिवर्तन पर पाबंदी है"

— ग्रेग मार्टिन

@GregMartin, आह, मैंने किसी तरह उस हिस्से को याद किया और केवल "क्रमचय के सूचकांक को वापस लौटा" भाग को देखा। मूर्खतापूर्ण मुझे ... नए कोड में वह मुद्दा नहीं है।

— जुंगह्वान मिन ऑक्ट

हाँ, मुझे लगता है कि यह याद करना आसान था। 74 बाइट्स - अभी भी बहुत प्रभावशाली!

— ग्रेग मार्टिन

5

MATL , 15 बाइट्स

:Y@tGY)Z)G:=!Af

इनपुट और आउटपुट 1-आधारित हैं।

के समान @ MartinEnder के CJam जवाब है, लेकिन इनपुट द्वारा निर्दिष्ट है कि के साथ सभी संभव क्रमपरिवर्तन रचना से उलटा क्रमचय पाता है, और दर्शन जो पहचान क्रमपरिवर्तन बन गया है।

यह इनपुट के लिए ऑनलाइन कंपाइलर में मेमोरी से बाहर निकलता है 10 ।

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

व्याख्या

:      % Implicitly input N. Push range [1 2 ... N]
Y@     % Matrix witll all permutations of size N. Each permutation is a row
tGY)   % Duplicate. Get the N-th row
Z)     % Use that as a column index into the matrix of all permutations
G:=    % Compare each row with [1 2 ... N]
!Af    % Find index of the row that matches. Implicitly display

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

5

पायथ, 12 बाइट्स

xJ.phQxL@JQh

परीक्षण सूट

0 अनुक्रमित।

स्पष्टीकरण:

xJ.phQxL@JQh
xJ.phQxL@JQhQ    Implicit variable introduction
                 Q = eval(input())
  .phQ           Form all permutations of range(Q+1), namely [0, 1, .. Q]
 J               Save to J.
        @JQ      Take the Qth element of J.
      xL   hQ    Map all elements of [0, 1, ..., Q] to their index in above
x                Find the index in J of the above.

— isaacg
स्रोत

5

05AB1E , 14 13 बाइट्स

~~बहुत स्मृति अक्षम।~~ अब और भी अधिक अक्षम स्मृति (लेकिन 1 बाइट छोटी)।
0-आधारित सीमा। CP-1252 एन्कोडिंग का
उपयोग करता है ।

ƒ¹ÝœD¹èNkˆ}¯k

इसे ऑनलाइन आज़माएं! या एक संशोधित परीक्षण सूट के रूप में

व्याख्या

ƒ               # for N in range[0 .. x]
 ¹ÝœD           # generate 2 copies of all permutations of range[0 .. x]
     ¹è         # get permutation at index x
       Nkˆ      # store index of N in that permutation in global list
         }      # end loop
          ¯k    # get index of global list (inverse) in list of permutations

— Emigna
स्रोत

4

सीजेएम , 16 बाइट्स

ri_)e!_@=_$\f#a#

संकेत 0-आधारित हैं।

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

मुझे इससे बहुत अधिक अक्षमता नहीं है ... अधिक से अधिक इनपुट के लिए जावा की डिफ़ॉल्ट सेटिंग्स के साथ स्मृति से बाहर चलाता है 8(लेकिन समय और मेमोरी के ब्रह्मांडों की पर्याप्त संख्या को देखते हुए मनमाने आदानों के लिए सिद्धांत रूप में काम करता है)।

व्याख्या

ri    e# Read input and convert to integer N.
_)e!  e# Duplicate N, get all permutations of [0 1 ... N].
_@=   e# Duplicate permutations, get the Nth permutation.
_$    e# Duplicate and sort to get the sorted range [0 1 ... N].
\f#   e# For each of these values, get its index in the Nth permutation.
      e# This inverts the permutation.
a#    e# Find the index of this new permutation in the list of all permutations.

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

3

जीएपी , 108 बाइट्स

h:=l->n->PositionProperty(l,p->l[n]*p=());
f:=n->h(Set(SymmetricGroup(First([1..n],k->Factorial(k)>=n))))(n);

1 अनुक्रमित। न्यूलाइन्स को गिना नहीं गया, उन्हें जरूरत नहीं है। मैं वास्तव में एक नाम के लिए अंतिम कार्य आवंटित नहीं है, लेकिन ...

hउस सूची में क्रमपरिवर्तन और एक सूचकांक की सूची लेने और उलटा अनुमति के सूचकांक को वापस करने के लिए एक करी कार्य है। प्रतिबंधों के बिना, मैं बस करूँगा Position(l,l[n]^-1)। fएक बड़े पर्याप्त सममित समूह और दिए गए क्रमबद्ध क्रमपरिवर्तन के साथ उस फ़ंक्शन को कॉल करता है n।

मैं बस लिख सकता था SymmetricGroup(n), फिर फ़ंक्शन को मानों के लिए 9 तक गणना की जा सकती थी। चूंकि पहले से ही बहुत छोटे समाधान हैं, इसलिए मैं ऐसा करने में सक्षम होना चाहता हूं:

gap> f(100001);
303017

वास्तव में कुशल 0-अनुक्रमित समाधान जो 99 से नीचे के तर्कों के लिए काम करता है! (और 999 से नीचे के तर्कों के लिए काम किया जा सकता है! एक बाइट की कीमत पर) यह एक है:

f:=function(n)
 local m,l,p,i,g;
 m:=First([1..99],k->Factorial(k)>n);
 g:=List([m-1,m-2..0],Factorial);
 l:=[1..m];
 p:=[];
 for i in g do
  Add(p,Remove(l,QuoInt(n,i)+1));
  n:=n mod i;
 od;
 return Sum(ListN(List([1..m],i->Number([1..Position(p,i)],j->p[j]>i)),g,\*));
end;

व्हॉट्सएप हटाने के बाद, इसमें 255 बाइट्स हैं।

— क्रिश्चियन सिवर्स
स्रोत

अच्छा काम! मुझे कुछ कुशल समाधान भी मिलने की उम्मीद थी।

— पुरकाकूदरी

3

जावास्क्रिप्ट (ईएस 6), 163 120 110 बाइट्स

f=(n,a=[],i=0,r=0,[j,...b]=a)=>n?a.splice(n%-~i,0,i)|f(n/++i|0,a,i):i?f(n,b,i-1,b.reduce((r,k)=>r+=k>j,r*i)):r

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

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

0 अनुक्रमित। अनुक्रमणिका को क्रमपरिवर्तन में परिवर्तित करके, उसे उलट कर, फिर एक अनुक्रमणिका में परिवर्तित करके काम करता है। संपादित करें: 25% के बारे में fउलटा बनाकर और क्रमचय gको उलट कर सहेजा गया , फिर उलटे क्रमपरिवर्तन को वापस एक अनुक्रमणिका में परिवर्तित कर दिया। एक ही फ़ंक्शन में दो पुनरावर्ती कॉल के संयोजन के द्वारा आगे के 10 बाइट्स को बचाया। Ungolfed:

function index(n) {
    var a = [0];
    for (var i = 1; n = Math.floor(n / i); i++) {
        var j = i - n % (i + 1);
        for (var k = 0; k < i; k++) {
            if (a[k] > j) a[k]++;
        }
        a.push(j);
    }
    a = [...a.keys()].map(k => a.indexOf(k));
    while (i) {
        n *= i--;
        j = a.pop();
        for (k = 0; k < i; k++) {
            if (a[k] > j) n++;
        }
    }
    return n;
}

— नील
स्रोत

1

@JonathanAllan क्षमा करें, मैंने सोचा था कि मैं एक अंतिम-9 बाइट की बचत कर रहा था, लेकिन मैं इसे अच्छी तरह से जांचने में विफल रहा। मैंने अपने पिछले संस्करण पर वापस लौटा लिया है।

— नील

अब बहुत ज़ोरदार क्रियान्वयन।

— जोनाथन एलन

1

@JonathanAllan ने कहा कि अगर मैं fइसके बजाय क्रमपरिवर्तन को उलटा कर दूं तो यह और भी अधिक स्वादिष्ठ होगा g।

— नील

3

जे, 55 50 बाइट्स

g=:/:~i.@#
[:(#\.#.+/@(<{.)\.)@g(-i.)@>:g@g@,/@#:]

क्रमपरिवर्तन सूचकांक पर जे निबंध के आधार पर ।

इस कोड को केवल के आदेश पर मेमोरी की आवश्यकता होती है n लेकिन अधिक समय का उपयोग करता है क्योंकि यह सूची के nसमय करता है और nप्रत्येक सूचकांक के लिए इसे खोजता है ।

बिलिन का उपयोग करना /: जो एक सूची के ग्रेड और एक क्रमचय के व्युत्क्रम को खोजने में सक्षम है, एक 42 बाइट समाधान है जो अधिक कुशल है।

[:(#\.#.+/@(<{.)\.)@/:(-i.)@>:/:@/:@,/@#:]

इस संस्करण में पिछले परीक्षण मामले की गणना करने के लिए केवल 44 सेकंड की आवश्यकता होती है जब दूसरे की तुलना में जिसे 105 सेकंड की आवश्यकता होती है।

प्रयोग

   g =: /:~i.@#
   f =: [:(#\.#.+/@(<{.)\.)@g(-i.)@>:g@g@,/@#:]
   (,.f"0) 0 1 2 3 4 5 6 13 42 100 1000 2000 10000
    0     0
    1     1
    2     2
    3     4
    4     3
    5     5
    6     6
   13    10
   42    51
  100    41
 1000  3628
 2000  3974
10000 30593
   timex 'r =: f 100000'
105.787
   r
303016

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

स्मृति दक्षता के लिए +1 जो गोल्फ भाषाओं को नहीं छू सकती।

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

2

जेली , १४ १३ 9 बाइट्स

-4 बाइट्स @ @ डेनिस के लिए धन्यवाद (जो उन्होंने अपने उत्तर⁺ में क्विक का उपयोग करते हुए आगे बढ़ाया )

Œ!ịịŒ!$iR

एक और बहुत धीमी गति से कार्यान्वयन।
1-आधारित अनुक्रमणिका यहां कार्यरत है, इसलिए अपेक्षित परिणाम हैं:

input:  1 2 3 4 5 6 7 8  9 10 11
output: 1 2 3 5 4 6 7 8 13 19  9

यहां तक कि एक ऑनलाइन आईडीई लिंक डालने का कोई मतलब नहीं है, क्योंकि TIO के इनपुट पर मारता है 10। स्थानीय परिणाम (अंतिम बहुत धीमा है और एक टन मेमोरी की आवश्यकता है!):

C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 1
1
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 2
2
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 3
3
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 4
5
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 5
4
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 6
6
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 7
7
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 8
8
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 9
13
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 10
19
C:\Jelly\jelly-master>python jelly -fu D:\jelly_scripts\revPerm.txt 11
9

कैसे?

Œ!ịịŒ!$iR - Main link 1: n
      $   - last two links as a monad
    Œ!    -     permutations of implicit range [1,2,3,...,n]
   ị      -     value at index n (the nth permutation)
Œ!        - permutations of implicit range [1,2,3,...,n]
  ị       - value at index (the indexes of the permuted values in the nth permutation)
       i  - index of
        R - range [1,2,3,...,n]

नोट: क्रमपरिवर्तन को क्रमबद्ध करने की कोई आवश्यकता नहीं है क्योंकि हम क्रमबद्धता को खोजने के लिए एक ही क्रम का उपयोग कर रहे हैं और यह उलटा है।

— जोनाथन एलन
स्रोत

मेरे फ़ोन से इसका परीक्षण नहीं किया जा सकता है, लेकिन क्या आप लिंक 2 से छुटकारा नहीं पा सकते हैं और मुख्य बना सकते हैं ÇịịÇ$iR?

— डेनिस

दरअसल, Rपहले Œ!निहित है, इसलिए Œ!ịịŒ!$iRकाम करना चाहिए।

— डेनिस

हाँ, दोस्तों से मिलने से पहले यह बहुत ही धमाकेदार एंट्री थी।

— जोनाथन एलन

2

पायथन 2, 116 114 बाइट्स

from itertools import*
def f(n):r=range(n+1);l=list(permutations(r));print l.index(tuple(l[n].index(v)for v in r))

repl.it

0-आधारित। धीमी और स्मृति भूख लेकिन बाइट्स पर कम।

बिना क्रमचय कार्यों का उपयोग करना; स्मृति और समय कुशल दोनों। 289 285 बाइट्स

-4 बाइट्स के लिए धन्यवाद @ क्रिसियन सिवर्स

h=lambda n,v=1,x=1:v and(n>=v and h(n,v*x,x+1)or(v,x-1))or n and h(n-1,0,n*x)or x
i=lambda p,j=0,r=0:j<len(p)and i(p,j+1,r+sum(k<p[j]for k in p[j+1:])*h(len(p)-j-1,0))or r
def f(n):t,x=h(n);g=range(x);o=g[:];r=[];exec"t/=x;x-=1;r+=[o.pop(n/t)];n%=t;"*x;return i([r.index(v)for v in g])

मुझे पता है कि यह कोड गोल्फ है, लेकिन मुझे लगता है कि @ Pietu1998 कुशल कार्यान्वयन में भी रुचि रखता है।

इसे repl.it पर कार्रवाई में देखें

हालांकि यह संदर्भ कार्यान्वयन की तुलना में अधिक बाइट्स का उपयोग करता है n=5000000:

ref:    6GB 148s  
this: 200KB <1ms

f रिवर्स इंडेक्स फ़ंक्शन है।

fपहले अगले भाज्य ऊपर हो जाता है n, tऔर पूर्णांक जिसका भाज्य है कि, xफोन करके h(n), और सेटg=range(x) , आइटम है कि क्रमचय अप कर देगा, o=g[:]और क्रमचय धारक,r=[]

अगला यह सूचकांक पर क्रमचय का निर्माण nद्वारा popकी भाज्य आधार प्रतिनिधित्व के अनुक्रमित ing nआइटम, से बारी में o, और उन से जोड़कर r। भाज्य आधार प्रतिनिधित्व div द्वारा पाया और का आधुनिक है nके साथ tजहां tसे div'd है xऔरx घटने के साथ होता है1 ।

अंत में यह रिवर्स क्रमचय के iसाथ कॉल करके रिवर्स क्रमचय के सूचकांक को ढूँढता है ,[r.index(v)for v in g]

h एक गैर-ऋणात्मक पूर्णांक के एक भाज्य की गणना या गैर-नकारात्मक पूर्णांक से ऊपर के अगले भाज्य की गणना और उस तथ्य को बनाने वाले पूर्णांक के लिए एक दोहरे उद्देश्य वाला कार्य है।

यह डिफ़ॉल्ट स्थिति में है v=1और यह बाद में गुणा vकरके x(शुरुआत में भी 1) करता है और xजब तक nकम से कम बड़ा नहीं होता है, तब तक यह बढ़ जाता है vऔरx-1 टुप में हो जाता है।

n!एक कॉल की गणना करने के लिए h(n,0)जो गुणक करता हैx (शुरू में 1) nगुणा करता है और nजब तक वापस नहीं आता तब तक घटता nहै0x ।

ipवस्तुओं के, क्रमपरिवर्तन के क्रमबद्ध सूचकांक प्रदान करता है[0,1,...n] प्रत्येक सूचकांक के भाज्य आधार के भाज्य के उत्पादों को जोड़कर h(len(p)-j-1,0), और कैसे सूचकांक के अधिकार के लिए कई मदों कि सूचकांक में मूल्य से कम कर रहे हैं, sum(k<p[j]for k in p[j+1:])।

— जोनाथन एलन
स्रोत

मुझे लगता है कि क्रमपरिवर्तन का निर्माण करते समय आपको अंतिम वस्तु के विशेष मामले की आवश्यकता नहीं है। मैं अपने 255 बाइट गैप समाधान में नहीं था।

— क्रिश्चियन सेवर्स

मैं इसे अंत में अलग से जोड़ता हूं क्योंकि जब ऐसा होता है तो शून्य त्रुटि से विभाजन होता है t/=x।

— जोनाथन एलन

मुझे कुछ समय लिया देखने के लिए: पाश पहले से ही करता है यह सब, आप बदल सकते हैं (r+o)द्वारा r।

— क्रिश्चियन सेवर्स

उह, आप सही हैं! बहुत बहुत धन्यवाद।

— जोनाथन एलन

1

पायथन 2, 130 129 बाइट्स

p=lambda x,k,j=1:x[j:]and p(x,k/j,j+1)+[x.pop(k%j)]
n=input();r=range(n+2);k=0
while[p(r*1,n)[i]for i in p(r*1,k)]>r:k+=1
print k

— डेनिस
स्रोत

1

दरअसल , 18 11 बाइट्स

यह उत्तर डेनिस के जेली उत्तर में एल्गोरिथ्म का उपयोग करता है, लेकिन 0-अनुक्रमित है। गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

4╞r;)╨E╨♂#í

Ungolfing

      Implicit input n.
4╞    Push 4 duplicates of n. Stack: n, n, n, n
r;)   Push the range [0...n], and move a duplicate of that range to BOS for later.
╨E    Push the n-length permutations of [0...n] and get perm_list[n].
        Stack: perm_list[n], n, [0...n]
╨     Push the n-length permutations of perm_list[n].
♂#    Convert every "list" in the zip to an actual list.
        Stack: perm(perm_list[n]), [0...n]
í     Get the index of [0...n] in the list of permutations of perm_list[n].
      Implicit return.

— Sherlock9
स्रोत

उलटा क्रमचय सूचकांक

परिचय

चुनौती

उदाहरण

संदर्भ कार्यान्वयन (पायथन 3)

जेली , 6 बाइट्स

सत्यापन

यह काम किस प्रकार करता है

वैकल्पिक दृष्टिकोण, 6 बाइट्स (अमान्य)

यह काम किस प्रकार करता है

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

व्याख्या

बिल्ट-इन, 46 43 बाइट्स का उपयोग करना

MATL , 15 बाइट्स

व्याख्या

पायथ, 12 बाइट्स

05AB1E , 14 13 बाइट्स

सीजेएम , 16 बाइट्स

व्याख्या

जीएपी , 108 बाइट्स

जावास्क्रिप्ट (ईएस 6), 163 120 110 बाइट्स

जे, 55 50 बाइट्स

प्रयोग

जेली , १४ १३ 9 बाइट्स

कैसे?

पायथन 2, 116 114 बाइट्स

बिना क्रमचय कार्यों का उपयोग करना; स्मृति और समय कुशल दोनों। 289 285 बाइट्स

पायथन 2, 130 129 बाइट्स

दरअसल , 18 11 बाइट्स