ভূমিকা

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… এন দেয় । উদাহরণস্বরূপ, ফলন প্রয়োগ (3,1,2)করা ।(2,3,1)(1,2,3)

আমরা এখন ফাংশন নির্ধারণ revind ( এক্স ) সঙ্গে সূচক বিন্যাস বিপরীত বিন্যাস সূচক যেমন এক্স । ( আপনি যদি আগ্রহী হন তবে এটি A056019 )

যেহেতু সূচকের সাথে একটি ক্রমায়ন আমি তালিকার শেষ k আইটেমগুলি কেবল if 0 ≤ i < কে ! সংশোধন করে তা পরিবর্তন করি , তাই আমরা পুনর্নির্দেশকে প্রভাবিত না করে তালিকার শুরুতে যে কোনও সংখ্যক উপাদান যুক্ত করতে পারি ( i )। সুতরাং তালিকার দৈর্ঘ্য ফলাফলকে প্রভাবিত করে না।

চ্যালেঞ্জ

আপনার কাজটি পুনর্নির্দেশ ( এক্স ) প্রয়োগ করা । আপনি একটি সম্পূর্ণ প্রোগ্রাম বা ফাংশন লিখবেন যা ইনপুট / আর্গুমেন্ট হিসাবে একক নননেজিটিভ পূর্ণসংখ্যার x গ্রহণ করে এবং ফলাফলটিকে একক নননেজিটিভ পূর্ণসংখ্যার হিসাবে ফলাফল প্রদান করে।

ইনপুট এবং আউটপুট 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

স্ক্যাটার প্লটটি বেশ মজার দেখাচ্ছে looks :)

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

1

এই চ্যালেঞ্জটি বুঝতে আমাকে বিপরীত ক্রমান্বয়ের সংজ্ঞাটি সন্ধান করতে হয়েছিল। আমি আপনার উদাহরণটি (a,b,c)অত্যন্ত অস্পষ্ট সহ খুঁজে পাই । বিপরীত ক্রমানুক্রম কী তা সম্পর্কে যথাযথ ব্যাখ্যা অন্তর্ভুক্ত করুন।

— 11:56

@ ফ্যাটালাইজ করুন এটি সহজভাবে ব্যাখ্যা করা খুব কঠিন। ভাল এখন?

— পূর্বকুডারী

জেলির এটম Ụ(গ্রেড আপ) রয়েছে যা তাদের সংশ্লিষ্ট মান অনুসারে একটি অ্যারের সূচকগুলি সাজায়। এটি 1,…, এন এর ক্রমবিন্যাসকে উল্টাতে ঘটে তবে এটি অন্যান্য ক্রমের জন্য কাজ করে না। হারাম কি অন্তর্নির্মিত? Ụ

— ডেনিস

@ ডেনিস হার্ড প্রশ্ন। প্রযুক্তিগতভাবে, এটি কোনও কঠোর ক্রমবর্ধমান তালিকায় প্রয়োগ করার পরে এটি কোনও ক্রমের বিপরীতটি আবিষ্কার করে। অতএব আমি বলতে চাইছি অনুমোদিত নয়। (যদি কেউ কঠোরভাবে একমত নন, মন্তব্য করতে দ্বিধা বোধ করবেন আমি তাই ইচ্ছা এই যদি সম্প্রদায় পরিবর্তন হতে পারে।।)

— 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

এটি ঠিক ততক্ষণ দীর্ঘ এবং এটি নিষিদ্ধ গ্রেড আপ অ্যাটম ব্যবহার করে Ụতবে এটি (যুক্তিযুক্ত) আরও বুদ্ধিমান।

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-ইনডেক্সিং ব্যবহার করে। খুব অদক্ষ। (ইনপুট থাকা অবস্থায় ~ 11 গিগাবাইট মেমরি ব্যবহার করে 11)

ব্যাখ্যা

j=Range@#

যে এন স্টোরে 1 থেকে একটি তালিকা তৈরি করুন 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

"বিল্টিনগুলি যা ... বিপরীত ক্রমানুসরণ নিষিদ্ধ রয়েছে"

— গ্রেগ মার্টিন

@ গ্রেগমার্টিন, আহ, আমি কোনও একরকম অংশটি মিস করেছি এবং কেবল "একটি অনুক্রমের সূচকটি ফেরত" দেখেছি। বোকা আমাকে ... নতুন কোডটিতে সমস্যা নেই।

— JangHwan Min

হ্যাঁ, আমি মনে করি এটি মিস করা সহজ ছিল। 74 বাইট - এখনও বেশ চিত্তাকর্ষক!

— গ্রেগ মার্টিন

5

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

05 এ বি 1 ই , 14 13 বাইট

~~খুব স্মৃতি অদক্ষ।~~ এখন আরও মেমরি অদক্ষ (তবে 1 বাইট ছোট)।
0-ভিত্তিক ব্যাপ্তি।
ব্যবহার সিপি-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

জাভাস্ক্রিপ্ট (ES6), 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-ইন্ডেক্স। সূচকে একটি ক্রমে রূপান্তর করে, উল্টানো, তারপরে সূচকে ফিরে রূপান্তর করে কাজ করে। সম্পাদনা: fউল্টানো এবং পেরিটুটেশনটি বিপরীত করে 25% সংরক্ষণিত, তারপরে 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

@ জোনাথান অ্যালান দুঃখিত, আমি ভেবেছিলাম আমি শেষ-দ্বিতীয় 9-বাইট সঞ্চয় সঞ্চয় করেছি তবে আমি এটি পুরোপুরি পরীক্ষা করতে ব্যর্থ হয়েছি। আমি আমার আগের সংস্করণে ফিরে এসেছি।

— নীল

এখন খুব কার্যকর বাস্তবায়ন।

— জোনাথন অ্যালান

1

@ জোনাথন অ্যালান আরও বেশি স্বাচ্ছন্দ্যে পরিণত হয়েছে যদি আমি fপরিবর্তে আদেশটি উল্টাতে পারি g...

— নীল

3

জে, 55 50 বাইট

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

জে রচনা উপর ভিত্তি করে পারমুটেশন সূচকে ।

এই কোডটি কেবল ক্রম অনুসারে মেমরির প্রয়োজন nতবে এটি তালিকা nবার সাজিয়ে এবং এটি অনুসন্ধান করার কারণে আরও সময় ব্যবহার করেn প্রতিটি সূচকের জন্য বারবার ।

কোনও বিল্টিন ব্যবহার করে /:যা কোনও তালিকার গ্রেড এবং একটি অনুক্রমের বিপরীতটি খুঁজে পেতে সক্ষম হয়, সেখানে একটি 42 বাইট সমাধান রয়েছে যা আরও দক্ষ efficient

[:(#\.#.+/@(<{.)\.)@/:(-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।

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

2

জেলি , 14 13 9 বাইট

-4 বাইট @Dennis ধন্যবাদ (যা তিনি আরও দ্রুত ব্যবহার golfed ⁺মধ্যে তার উত্তর )

Œ!ịịŒ!$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

এমনকি কোনও অনলাইন আইডিই লিঙ্ক স্থাপনের কোনও অর্থ নেই, কারণ টিআইও একটি ইনপুটটিতে হত্যা করে 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])

আমি জানি এটি কোড গল্ফ তবে আমি মনে করি @ পিটু 1998 দক্ষ প্রয়োগের ক্ষেত্রেও আগ্রহী।

এটি 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। কল্পিত বেসের উপস্থাপনাটি ডিভ এবং মোডের nসাথে পাওয়া যায় tযেখানে tবিভাজন হয় 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এবং decrements nপর্যন্ত nহয় 0যখন এটি ফেরৎ x।

iপ্রতিটি সূচকের ফ্যাক্টরিয়াল বেসের ফ্যাক্টরিয়াল এর পণ্যগুলি যুক্ত pকরে আইটেমগুলির ক্রমশারণের শব্দকোষের সূচক সরবরাহ করে এবং সূচকের ডানদিকে কতগুলি আইটেম সেই সূচকের মানের চেয়ে কম হয় ,।[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 বাইট

এমএটিএল , 15 বাইট

ব্যাখ্যা

পাইথ, 12 বাইট

05 এ বি 1 ই , 14 13 বাইট

সিজেম , 16 বাইট

ব্যাখ্যা

জিএপি , 108 বাইট

জাভাস্ক্রিপ্ট (ES6), 163 120 110 বাইট

জে, 55 50 বাইট

ব্যবহার

জেলি , 14 13 9 বাইট

কিভাবে?

পাইথন 2, 116 114 বাইট

কোন ক্রমবর্ধমান ফাংশন ব্যবহার করে; স্মৃতি এবং সময় উভয়ই কার্যকর। 289 285 বাইট

পাইথন 2, 130 129 বাইট

আসলে , 18 11 বাইট