0.0% ≤ diff ≤ 20.0%

4 clusters, 11 submissions
all: cluster #1 (5)
# 6231103521  (2020-10-25 21:09) %diff = 0.0 90%


def order_of(permutation):
    p = permutation
    n = len(permutation)
    nfac = math.factorial(n)
    pos = nfac
    num = [ e for e in range(1,n+1)]
    for i in range(n-1):
        pos -= ((n - 1*i)  - (num.index(p[i]) + 1)) * math.factorial(n-i-1)
        num.remove(p[i])
    return pos
#---------------------------------

def permutation_at(order, n):
    if order > math.factorial(n) or order == 0:
        return "None"
    ans = []
    num = [ e for e in range(1,n+1)]
    for i in range(n):
        factor = math.factorial(n - (i + 1))
        if order % factor == 0:
            index = (order//factor) - 1
        else:
            index = (order//factor)
        order -= index * factor
        ans.append(num[index])
        num.pop(index)
    return ans
#----------------- ----------------

def next_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order + 1, n)
    return ans
#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order - 1, n)
    return ans
#---------------------------------

def longest_cycles(permutation):
    ans = []
    p = [0]
    for e in permutation:
        p.append(e)
    n = len(p)
    check = 1
    pcheck = p[check]
    cy = [pcheck]
    max_cy = 0
    while True:
        if check == 0: break
        if pcheck != check:
            cy.append(p[pcheck])
            pcheck = p[pcheck]
        else:
            if len(cy) >= max_cy:
                ans.append(cy)
                max_cy = len(cy)
            check += 1
            check %= n
            pcheck = p[check]
            cy = [pcheck]
    real_ans = []
    for e in ans:
        if len(e) == max_cy:
            real_ans.append(e)
    return real_ans
# 6231502221  (2020-10-25 21:37) %diff = 10.83 90%


def order_of(permutation):
    p = permutation
    n = len(permutation)
    pos = math.factorial(n)
    num = [ e for e in range(1,n+1)]
    for i in range(n-1):
        pos -= ((n - 1*i)  - (num.index(p[i]) + 1)) * math.factorial(n-i-1)
        num.remove(p[i])
    return pos
#---------------------------------

def permutation_at(order, n):
    if order > math.factorial(n) or order == 0:
        return "None"
    ans = []
    num = [ e for e in range(1,n+1)]
    for i in range(n):
        factor = math.factorial(n - (i + 1))
        if order % factor == 0:
            index = (order//factor) - 1
        else:
            index = (order//factor)
        order -= index * factor
        ans.append(num[index])
        num.pop(index)
    return ans

#----------------- ----------------

def next_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order + 1, n)
    return ans
#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order - 1, n)
    return ans
#---------------------------------

def longest_cycles(permutation):
    ans = []
    p = [0]
    for e in permutation:
        p.append(e)
    n = len(p)
    check = 1
    pcheck = p[check]
    cycle = [pcheck]
    max_cycle = 0
    while True:
        if check == 0:
            break
        if pcheck != check:
            cycle.append(p[pcheck])
            pcheck = p[pcheck]
        else:
            if len(cycle) >= max_cycle:
                ans.append(cycle)
                max_cycle = len(cycle)
            check += 1
            check %= n
            pcheck = p[check]
            cycle = [pcheck]
    real_ans = []
    for e in ans:
        if len(e) == max_cycle:
            real_ans.append(e)
    return real_ans

#----------------------------------------------------------------
# 6231125321  (2020-10-25 21:51) %diff = 1.63 64%


def order_of(permutation):
    pe = permutation
    n = len(permutation)
    nfac = math.factorial(n)
    pos = nfac
    num = [ e for e in range(1,n+1)]
    for i in range(n-1):
        pos -= ((n - 1*i)  - (num.index(pe[i]) + 1)) * math.factorial(n-i-1)
        num.remove(pe[i])
    return pos
#---------------------------------

def permutation_at(order, n):
    if order > math.factorial(n) or order == 0:
        return "None"
    ans = []
    num = [ e for e in range(1,n+1)]
    for i in range(n):
        factor = math.factorial(n - (i + 1))
        if order % factor == 0:
            index = (order//factor) - 1
        else:
            index = (order//factor)
        order -= index * factor
        ans.append(num[index])
        num.pop(index)
    return ans
#----------------- ----------------

def next_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order + 1, n)
    return ans
#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order - 1, n)
    return ans
#---------------------------------

def longest_cycles(permutation):
    ans = []
    pe = [0]
    for e in permutation:
        pe.append(e)
    n = len(pe)
    check = 1
    pcheck = pe[check]
    cy = [pcheck]
    max_cy = 0
    while True:
        if check == 0: break
        if pcheck != check:
            cy.append(pe[pcheck])
            pecheck = pe[pcheck]
        else:
            if len(cy) >= max_cy:
                ans.append(cy)
                max_cy = len(cy)
            check += 1
            check %= n
            pecheck = pe[check]
            cy = [pecheck]
    real_ans = []
    for e in ans:
        if len(e) == max_cy:
            real_ans.append(e)
    return real_ans
# 6231117321  (2020-10-25 21:59) %diff = 0.0 90%


def order_of(permutation):
    p = permutation
    n = len(permutation)
    nfac = math.factorial(n)
    pos = nfac
    num = [ e for e in range(1,n+1)]
    for i in range(n-1):
        pos -= ((n - 1*i)  - (num.index(p[i]) + 1)) * math.factorial(n-i-1)
        num.remove(p[i])
    return pos
#---------------------------------

def permutation_at(order, n):
    if order > math.factorial(n) or order == 0:
        return "None"
    ans = []
    num = [ e for e in range(1,n+1)]
    for i in range(n):
        factor = math.factorial(n - (i + 1))
        if order % factor == 0:
            index = (order//factor) - 1
        else:
            index = (order//factor)
        order -= index * factor
        ans.append(num[index])
        num.pop(index)
    return ans
#----------------- ----------------

def next_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order + 1, n)
    return ans
#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order - 1, n)
    return ans
#---------------------------------

def longest_cycles(permutation):
    ans = []
    p = [0]
    for e in permutation:
        p.append(e)
    n = len(p)
    check = 1
    pcheck = p[check]
    cy = [pcheck]
    max_cy = 0
    while True:
        if check == 0: break
        if pcheck != check:
            cy.append(p[pcheck])
            pcheck = p[pcheck]
        else:
            if len(cy) >= max_cy:
                ans.append(cy)
                max_cy = len(cy)
            check += 1
            check %= n
            pcheck = p[check]
            cy = [pcheck]
    real_ans = []
    for e in ans:
        if len(e) == max_cy:
            real_ans.append(e)
    return real_ans
# 6231514821  (2020-10-25 22:42) %diff = 0.0 90%


def order_of(permutation):
    p = permutation
    n = len(permutation)
    nfac = math.factorial(n)
    pos = nfac
    num = [ e for e in range(1,n+1)]
    for i in range(n-1):
        pos -= ((n - 1*i)  - (num.index(p[i]) + 1)) * math.factorial(n-i-1)
        num.remove(p[i])
    return pos
#---------------------------------

def permutation_at(order, n):
    if order > math.factorial(n) or order == 0:
        return "None"
    ans = []
    num = [ e for e in range(1,n+1)]
    for i in range(n):
        factor = math.factorial(n - (i + 1))
        if order % factor == 0:
            index = (order//factor) - 1
        else:
            index = (order//factor)
        order -= index * factor
        ans.append(num[index])
        num.pop(index)
    return ans
#----------------- ----------------

def next_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order + 1, n)
    return ans
#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    order = order_of(permutation)
    ans = permutation_at(order - 1, n)
    return ans
#---------------------------------

def longest_cycles(permutation):
    ans = []
    p = [0]
    for e in permutation:
        p.append(e)
    n = len(p)
    check = 1
    pcheck = p[check]
    cy = [pcheck]
    max_cy = 0
    while True:
        if check == 0: break
        if pcheck != check:
            cy.append(p[pcheck])
            pcheck = p[pcheck]
        else:
            if len(cy) >= max_cy:
                ans.append(cy)
                max_cy = len(cy)
            check += 1
            check %= n
            pcheck = p[check]
            cy = [pcheck]
    real_ans = []
    for e in ans:
        if len(e) == max_cy:
            real_ans.append(e)
    return real_ans
all: cluster #2 (2)
# 6331116821  (2020-10-25 21:24) %diff = 12.33 100%


def order_of(permutation):
    num = list()
    n = len(permutation)
    order = 1
    ist = 1
    for e in range(1,n+1):
        num.append(e)
    for i in range(2,n+1):
        ist *= i

    est = ist
    for i in range(n):
        est = est//(n-i)
        m = permutation[i]
        order +=(num.index(m))*est
        num.pop(num.index(m))
    return order

#---------------------------------

def permutation_at(order, n):
    ist = 1
    ans = list()
    num = list()
    for e in range(1,n+1):
        num.append(e)
    for i in range(2,n+1):
        ist *= i

    if order == 0 or order > ist:
        return None
    me = 0
    est = ist
    for i in range(1,n+1):
        est = est//(n-i+1)
        for j in range(1,n+1):
            if order <= j*est + me:
                m = num[j-1]
                ans.append(m)
                me = (j-1)*est + me
                num.pop(num.index(m))
                break
    return ans


#---------------------------------

def next_permutation(permutation):
    n = len(permutation)
    m = order_of(permutation)
    return permutation_at(m+1,n)

#---------------------------------

def prev_permutation(permutation):
    n = len(permutation)
    m = order_of(permutation)
    return permutation_at(m-1,n)

#---------------------------------

def longest_cycles(permutation):
    q = 0
    k = list()
    n = len(permutation)
    for i in range(1,n+1):
        c = i
        b = [c]
        while True:
            c = permutation[c-1]
            if c == i:
                break
            b.append(c)
        k.append(b)
        q = max(q,len(b))
    ans = list()
    mem = set()
    for m in k:
        if len(m) == q:
            if m[0] not in mem:
                ans.append(m)
                for i in m:
                    mem.add(i)

    return ans
#---------------------------------
# 6330007921  (2020-10-25 22:13) %diff = 12.33 100%


def order_of(permutation):
    n = len(permutation)
    order = 1
    fact = 1
    number = list()
    for e in range(1,n+1):
        number.append(e)
    for i in range(2,n+1):
        fact*=i

    fact2 = fact
    for i in range(n):
        fact2 = fact2//(n-i)
        a = permutation[i]
        order+=(number.index(a))*fact2
        number.pop(number.index(a))
    return order
#---------------------------------

def permutation_at(order, n):
    ans = list()
    fact = 1
    number = list()
    for e in range(1,n+1):
        number.append(e)
    for i in range(2,n+1):
        fact*=i

    if order > fact or order == 0:
        return None
    fact2 = fact
    st = 0
    for i in range(1,n+1):
        fact2 = fact2//(n-i+1)
        for j in range(1,n+1):
            if order <= st + j*fact2:
                a = number[j-1]
                ans.append(a)
                st = st + (j-1)*fact2
                number.pop(number.index(a))
                break
    return ans
#---------------------------------

def next_permutation(permutation):
    a = order_of(permutation)
    n = len(permutation)
    return permutation_at(a+1,n)
#---------------------------------

def prev_permutation(permutation):
    a = order_of(permutation)
    n = len(permutation)
    return permutation_at(a-1,n)
#---------------------------------

def longest_cycles(permutation):
    n = len(permutation)
    mx = 0
    l = list()
    for i in range(1,n+1):
        cur = i
        cyc = [cur]
        while True:
            cur = permutation[cur-1]
            if cur == i:
                break
            cyc.append(cur)
        l.append(cyc)
        mx = max(mx,len(cyc))
    ans = list()
    mem = set()
    for a in l:
        if len(a)==mx:
            if a[0] not in mem:
                ans.append(a)
                for i in a:
                    mem.add(i)
    return ans
#---------------------------------
all: cluster #3 (2)
# 6331018021  (2020-10-24 23:49) %diff = 12.69 89%


def order_of(permutation):
    s = 0
    while permutation:
        s = s*len(permutation)+sorted(permutation).index(permutation.pop(0))
    return s+1

def permutation_at(order, n):
    arr = [i for i in range(1, n+1)]
    ans = []
    if math.factorial(n) < order:
        return None
    while arr:
        index = order//(math.factorial(len(arr)-1))

        if(order % (math.factorial(len(arr)-1)) == 0):
            index -= 1
        ans.append(arr[index])

        order = order-(math.factorial(len(arr)-1))*index
        arr.remove(arr[index])
    return ans

def next_permutation(permutation):
    i = len(permutation) - 1
    sorted_list = sorted(permutation, reverse=True)
    if permutation == sorted_list:
        return None
    while i > 0 and permutation[i] <= permutation[i-1]:
        i -= 1
    if i == 0:
        permutation.reverse()
    else:
        j = i
        i -= 1
        while j < len(permutation) and permutation[j] > permutation[i]:
            j += 1
        j -= 1
        permutation[j], permutation[i] = permutation[i], permutation[j]
        permutation[i+1:] = permutation[i+1:][::-1]
    return permutation

def prev_permutation(permutation):
    n = len(permutation) - 1
    i = n
    while i > 0 and permutation[i-1] <= permutation[i]:
        i -= 1
    if i <= 0:
        return None

    j = i - 1
    while (j + 1 <= n and
           permutation[j + 1] <= permutation[i - 1]):
        j += 1

    temp = permutation[i-1]
    permutation[i-1] = permutation[j]
    permutation[j] = temp

    permutation[::-1]

    return permutation

def longest_cycles(permutation):
    pass
    listall = list()
    check = list()
    for i in range(len(permutation)) :
        if permutation[i] not in check :
            temp = list()
            x = permutation[i]
            y = permutation[x - 1]
            temp.append(x)
            check.append(x)
            while(x != y) :
                temp.append(y)
                check.append(y)
                y = permutation[y - 1]
            listall.append(temp)
    longest = max([len(e) for e in listall])
    longestlist = list()
    for i in listall:
        if len(i)==longest:
            longestlist.append(i)
    return longestlist
# 6330204121  (2020-10-25 23:12) %diff = 12.69 89%


def order_of(permutation):
    a = 0
    while permutation:
        a = a*len(permutation) + sorted(permutation).index(permutation.pop(0))
    return a+1

def permutation_at(order, n):
    a = [i for i in range(1, n+1)]
    ans = []
    if math.factorial(n) < order:
        return None
    while a:
        e = order//(math.factorial(len(a)-1))

        if(order % (math.factorial(len(a)-1)) == 0):
            e -= 1
        ans.append(a[e])

        order = order-(math.factorial(len(a)-1))*e
        a.remove(a[e])
    return ans

def next_permutation(permutation):
    i = len(permutation) - 1
    list_work = sorted(permutation, reverse=True)
    if permutation == list_work:
        return None
    while i > 0 and permutation[i] <= permutation[i-1]:
        i -= 1
    if i == 0:
        permutation.reverse()
    else:
        j = i
        i -= 1
        while j < len(permutation) and permutation[j] > permutation[i]:
            j += 1
        j -= 1
        permutation[j], permutation[i] = permutation[i], permutation[j]
        permutation[i+1:] = permutation[i+1:][::-1]
    return permutation

def prev_permutation(permutation):
    i = len(permutation) - 1
    x = i
    while i > 0 and permutation[i-1] <= permutation[i]:
        i -= 1
    if i <= 0:
        return None
    ii = i - 1
    while (ii + 1 <= x and
           permutation[ii + 1] <= permutation[ii - 1]):
        ii += 1
    m = permutation[i-1]
    permutation[i-1] = permutation[ii]
    permutation[ii] = m
    permutation[::-1]

    return permutation

def longest_cycles(permutation):
    pass

    lists = list()
    check = list()

    for i in range(len(permutation)) :
        if permutation[i] not in check :
            m = list()
            x = permutation[i]
            y = permutation[x - 1]
            m.append(x)
            check.append(x)
            while(x != y) :
                m.append(y)
                check.append(y)
                y = permutation[y - 1]
            lists.append(m)

    longest = max([len(e) for e in lists])
    longestlist = list()

    for i in lists:
        if len(i)==longest:
            longestlist.append(i)
    return longestlist
all: cluster #4 (2)
# 6331126021  (2020-10-25 01:41) %diff = 17.91 76%


def order_of(permutation):
    s = 0
    a = 1
    sp = [permutation[-1]]
    for i in range(2, 1+len(permutation)):
        sp.append(permutation[len(permutation)-i])
        sp.sort()
        s = s+a*sp.index(permutation[len(permutation)-i])
        a = a*i
    return s+1
#---------------------------------

def permutation_at(order, n):
    order = order - 1
    left = [i for i in range(1,n + 1)]
    fac = math.factorial(n)
    if order >=fac:
        return None
    permutation = []
    for i in range(n,0,-1):
        ind = ((order%fac)*i)//fac
        permutation.append(left[ind])
        del left[ind]
        fac = fac//i
    return permutation
#---------------------------------

def next_permutation(permutation):
    start = -1
    for i in range(len(permutation)-1):
        if permutation[i] < permutation[i+1]:
            start = i
    if start == -1:
        return None
    left = sorted(permutation[start:])
    ind = left.index(permutation[start])
    next_permutation = permutation[:start]
    next_permutation.append(left[ind+1])
    return next_permutation + left[:ind+1] + left[ind+2:]
#---------------------------------

def prev_permutation(permutation):
    start = -1
    for i in range(len(permutation)-1):
        if permutation[i] > permutation[i+1]:
            start = i
    if start == -1:
        return None
    left = sorted(permutation[start:], reverse = True)
    ind = left.index(permutation[start])
    prev_permutation = permutation[:start]
    prev_permutation.append(left[ind+1])
    return prev_permutation + left[:ind+1] + left[ind+2:]
#---------------------------------

def longest_cycles(permutation):
    maxlen = 0
    left = {}
    longest = []
    for i in range(len(permutation)):
        left[permutation[i]] = i+1
    for x in permutation:
        next_ind = left.get(x)
        if next_ind != None:
            cycle = [x]
            next_ind = left[x]
            while True:
                if next_ind == x:
                    break
                cycle.append(next_ind)
                next_ind = left[next_ind]
            for j in cycle:
                del left[j]
            if len(cycle) == maxlen:
                longest.append(cycle)
            elif len(cycle) > maxlen:
                maxlen = len(cycle)
                longest = [cycle]
    return sorted(longest)
#---------------------------------
# 6331117421  (2020-10-25 23:46) %diff = 17.91 76%


def order_of(permutation):
    s = 0
    mul = 1
    used = [permutation[-1]]
    for i in range(2, 1+len(permutation)):
        used.append(permutation[len(permutation)-i])
        used.sort()
        s += used.index(permutation[len(permutation)-i]) * mul
        mul *= i
    return s+1
#---------------------------------

def permutation_at(order, n):
    order -= 1
    not_use = [i for i in range(1,n + 1)]
    nf = math.factorial(n)
    if order >= nf:
        return None
    permutation = []
    for i in range(n,0,-1):
        ind = ((order%nf)*i)//nf
        permutation.append(not_use[ind])
        del not_use[ind]
        nf //= i
    return permutation
#---------------------------------

def next_permutation(permutation):
    begin = -1
    for i in range(len(permutation)-1):
        if permutation[i] < permutation[i+1]:
            begin = i
    if begin == -1:
        return None
    not_used = sorted(permutation[begin:])
    ind = not_used.index(permutation[begin])
    next_permu = permutation[:begin]
    next_permu.append(not_used[ind+1])
    return next_permu + not_used[:ind+1] + not_used[ind+2:]
#---------------------------------

def prev_permutation(permutation):
    begin = -1
    for i in range(len(permutation)-1):
        if permutation[i] > permutation[i+1]:
            begin = i
    if begin == -1:
        return None
    not_used = sorted(permutation[begin:], reverse = True)
    ind = not_used.index(permutation[begin])
    prev_permu = permutation[:begin]
    prev_permu.append(not_used[ind+1])
    return prev_permu + not_used[:ind+1] + not_used[ind+2:]
#---------------------------------

def longest_cycles(permutation):
    not_used = {}
    longest = []
    max_len = 0
    for i in range(len(permutation)):
        not_used[permutation[i]] = i+1
    for x in permutation:
        next_ind = not_used.get(x)
        #print(x, next_ind)
        if next_ind != None:
            cycle = [x]
            next_ind = not_used[x]
            #print(' ',next_ind, x)
            while next_ind != x:
                cycle.append(next_ind)
                next_ind = not_used[next_ind]
                #print(' ',next_ind, x)
            for d in cycle:
                del not_used[d]
            if len(cycle) > max_len:
                max_len = len(cycle)
                longest = [cycle]
            elif len(cycle) == max_len:
                longest.append(cycle)
    return longest
#---------------------------------